• 20 hours
  • Easy

Free online content available in this course.

Paperback available in this course

course.header.alt.is_certifying

You can get support and mentoring from a private teacher via videoconference on this course.

Got it!

Last updated on 11/28/19

Tableaux, listes et énumérations

Log in or subscribe for free to enjoy all this course has to offer!

Dans les chapitres précédents, nous avons pu utiliser les types de base du framework .NET, comme int, string, double, etc. Nous allons découvrir ici d'autres types qui vont s'avérer très utiles dans la construction de nos applications informatiques. 

Une fois bien maîtrisés, vous ne pourrez plus vous en passer ! :p

Les tableaux

Voici le premier nouveau type que nous allons étudier, le type « tableau ». En déclarant une variable de type tableau, nous allons en fait utiliser une variable qui contient une suite de variables du même type. Prenons cet exemple :

string[] jours = new string[] { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };

Nous définissons ici un tableau de chaine de caractères qui contient 7 chaines de caractères, à savoir les jours de la semaine. Ne faites pas trop attention à l’opérateur new pour l’instant, nous y reviendrons dans le prochain cours; il permet simplement de créer le tableau.
Les crochets « [] » qui suivent le nom du type permettent de signaler au compilateur que nous souhaitons utiliser un tableau de ce type-là, ici le type string .

Un tableau, c’est un peu comme une armoire dans laquelle on range des variables. Chaque variable est posée sur une étagère. Pour accéder à la variable qui est posée sur une étagère, on utilise le nom de l’armoire et on indique l’indice de l’étagère où est stockée la variable, en utilisant des crochets [] :

Console.WriteLine(jours[3]); // affiche Jeudi
Console.WriteLine(jours[0]); // affiche Lundi
Console.WriteLine(jours[10]); // provoque une erreur d'exécution car l'indice n'existe pas

Sans anticiper sur le chapitre sur les boucles, il est possible de parcourir l’ensemble d’un tableau avec l’instruction suivante :

string[] jours = new string[] { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };
for (int i = 0; i < jours.Length; i++)
{
    Console.WriteLine(jours[i]);
}

Nous y reviendrons plus tard mais pour comprendre, ici nous parcourons les éléments de 0 à taille-1 et nous affichons l’élément du tableau correspondant à l’indice en cours.

Ce qui nous donne :

Image utilisateur

Revenons à présent sur la déclaration du tableau :

string[] jours = new string[] { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };

Cette écriture permet de créer un tableau qui contient 7 éléments et d’affecter une valeur à chaque élément du tableau. Il s’agit en fait ici d’une écriture simplifiée. Cette écriture est équivalente à celle-ci :

string[] jours = new string[7];
jours[0] = "Lundi";
jours[1] = "Mardi";
jours[2] = "Mercredi";
jours[3] = "Jeudi";
jours[4] = "Vendredi";
jours[5] = "Samedi";
jours[6] = "Dimanche";

qui est beaucoup plus verbeuse, mais d’un autre côté, plus explicite.

La première instruction crée un tableau qui peut contenir 7 éléments. 7 indique la taille du tableau, elle ne peut pas changer. Chaque instruction suivante affecte une valeur à un indice du tableau. Rappelez-vous, un tableau commence à l’indice 0 et va jusqu’à l’indice taille – 1.

Il est possible facilement de faire des opérations sur un tableau, comme un tri. On pourra utiliser la méthode Array.Sort(). Par exemple :

Array.Sort(jours);

Avec cette instruction, le tableau sera classé par ordre alphabétique. Vous aurez l’occasion de voir d’autres méthodes dans des chapitres ultérieurs.
Ainsi, le code suivant :

string[] jours = new string[] { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };
Array.Sort(jours);
for (int i = 0; i < jours.Length; i++)
{
    Console.WriteLine(jours[i]);
}

produira :

Image utilisateur

Ce qui est très inutile :) .

Le tableau « jours » est ce que l’on appelle un tableau à une dimension. Il est également possible de créer des tableaux à N dimensions, il est cependant assez rare de dépasser 2 dimensions. Cela est utile lorsque l’on manipule des matrices.

Nous n'étudierons pas les tableaux à plus d'une dimension dans ce tutoriel car ils risquent de vraiment peu vous servir dans vos premières applications. Par contre, le type suivant vous servira abondamment.

Les listes

Un autre type que nous allons utiliser à foison est la liste. Nous allons voir comment ce type fonctionne mais sans en faire une étude exhaustive car elle pourrait être bien longue et ennuyeuse. Regardons cet exemple :

List<int> chiffres = new List<int>(); // création de la liste
chiffres.Add(8); // chiffres contient 8
chiffres.Add(9); // chiffres contient 8, 9
chiffres.Add(4); // chiffres contient 8, 9, 4

chiffres.RemoveAt(1); // chiffres contient 8, 4

foreach (int chiffre in chiffres)
{
    Console.WriteLine(chiffre);
}

La première ligne permet de créer la liste. Nous reviendrons sur cette instruction un peu plus bas dans le chapitre. Il s’agit d’une liste d’entiers.

Nous ajoutons des entiers à la liste grâce à la méthode Add(). Nous ajoutons en l’occurrence les entiers 8, 9 et 4.

La méthode RemoveAt() permet de supprimer un élément en utilisant son indice, ici nous supprimons le deuxième entier, c’est-à-dire 9.

Après cette instruction, la liste contient les entiers 8 et 4.

Enfin, nous parcourons les éléments de la liste grâce à l’instruction foreach. Nous y reviendrons en détail lors du chapitre sur les boucles. Pour l’instant, nous avons juste besoin de comprendre que nous affichons tous les éléments de la liste.

Ce qui donne :

Image utilisateur

Les lecteurs assidus auront remarqués que la construction de la liste est un peu particulière. Passons sur le mot clé new qui permet de créer la liste, nous y reviendrons plus en détail dans le prochain cours. Par contre, on observe l’utilisation de chevrons <> pour indiquer le type de la liste. Pour avoir une liste d’entier, il suffit d’indiquer le type int à l’intérieur des chevrons. Ainsi, il ne sera pas possible d’ajouter autre chose qu’un entier dans cette liste. Par exemple, l’instruction suivante provoque une erreur de compilation :

List<int> chiffres = new List<int>(); // création de la liste
chiffres.Add("chaine"); // ne compile pas

Evidemment, on ne peut pas ajouter des choux à une liste de carottes !

De la même façon, si l’on souhaite créer une liste de chaine de caractères, nous pourrons utiliser le type string à l’intérieur des chevrons :

List<string> chaines = new List<string>(); // création de la liste
chaines.Add("chaine"); // compilation OK
chaines.Add(1); // compilation KO, on ne peut pas ajouter un entier dans une liste de chaines de caractères

Les listes possèdent des méthodes bien pratiques qui permettent toutes sortes d’opérations sur la liste. Par exemple, la méthode IndexOf() permet de rechercher un élément dans la liste et de renvoyer son indice.

List<string> jours = new List<string>();
jours.Add("Lundi");
jours.Add("Mardi");
jours.Add("Mercredi");
jours.Add("Jeudi");
jours.Add("Vendredi");
jours.Add("Samedi");
jours.Add("Dimanche");

int indice = jours.IndexOf("Mercredi"); // indice vaut 2

Nous aurons l’occasion de voir d’autres utilisations de méthodes de la liste dans d'autres chapitres et dans les prochains cours.

La liste que nous venons de voir (List <> ) est en fait ce que l’on appelle un type générique. Nous n’allons pas rentrer dans le détail de ce qu’est un type générique pour l’instant, mais il faut juste savoir qu’un type générique permet d’être spécialisé par un type concret. Pour notre liste, cette généricité permet d’indiquer de quel type est la liste, une liste d’entiers ou une liste de chaines de caractères, etc …

Ne vous inquiétez pas si tout ceci n’est pas parfaitement clair, nous reviendrons plus en détail sur les génériques dans le prochain cours. Le but ici est de commencer à se familiariser avec le type List<> que nous utiliserons régulièrement et les exemples que nous verrons permettront d’appréhender les subtilités de ce type.

À noter qu’il existe également une écriture simplifiée des listes. En effet, il est possible de remplacer :

List<string> jours = new List<string>();
jours.Add("Lundi");
jours.Add("Mardi");
jours.Add("Mercredi");
jours.Add("Jeudi");
jours.Add("Vendredi");
jours.Add("Samedi");
jours.Add("Dimanche");

par

List<string> jours = new List<string> { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };

un peu comme pour les tableaux.

Liste ou tableau ?

Vous aurez remarqué que les deux types, tableau et liste, se ressemblent beaucoup. Essayons de voir ce qui les différencie afin de savoir quel type choisir entre les deux.

En fait, une des grosses différences est que le tableau peut être multidimensionnel. C’est un point important mais dans le cadre de vos premières applications, il est relativement rare d’avoir à s’en servir. Ils serviront globalement plus souvent dans le développement de jeux ou lorsque l’on souhaite faire des calculs 3D.

Par contre, le plus important pour nous est que le type tableau est de taille fixe alors que la liste est de taille variable. On peut ajouter sans problèmes un nouvel élément grâce à la méthode Add(). De même, on peut supprimer des éléments avec les méthodes Remove alors qu’avec un tableau, on peut seulement remplacer les valeurs existantes et il n’est pas possible d’augmenter sa capacité.

Globalement, vous verrez que dans vos applications, vous utiliserez plutôt les listes pour par exemple afficher une liste de produits, une liste de clients, etc …

Gardez quand même dans un coin de l’esprit les tableaux, ils pourront vous aider dans des situations précises.

Les énumérations

Un type particulier que nous allons également utiliser est l’énumération. Cela correspond comme son nom l’indique à une énumération de valeur.

Par exemple, il pourrait être très facile de représenter les jours de la semaine dans une énumération plutôt que dans un tableau.

On définit l’énumération de cette façon, grâce au mot clé enum :

enum Jours
{
    Lundi,
    Mardi,
    Mercredi,
    Jeudi,
    Vendredi,
    Samedi,
    Dimanche
}

À noter qu’on ne peut pas définir cette énumération n’importe où, pour l’instant, contentons-nous de la définir en dehors de la méthode Main().

Pour être tout à fait précis, une énumération est un type dont toutes les valeurs définies sont des entiers. La première vaut 0, et chaque valeur suivante prend la valeur précédente augmentée de 1. C'est-à-dire que Lundi vaut 0, Mardi vaut 1, etc …

Il est possible de forcer des valeurs à toutes ou certaines valeurs de l’énumération, les valeurs non forcées prendront la valeur précédente augmentée de 1 :

enum Jours
{
    Lundi = 5, // lundi vaut 5
    Mardi, // mardi vaut 6
    Mercredi = 9, // mercredi vaut 9
    Jeudi = 10, // jeudi vaut 10
    Vendredi, // vendredi vaut 11
    Samedi, // samedi vaut 12
    Dimanche = 20 // dimanche vaut 20
}

Mais, à part pour enregistrer une valeur dans une base de données, il est rare de manipuler les énumérations comme des entiers car le but de l’énumération est justement d’avoir une liste exhaustive et fixée de valeurs constantes. Le code s’en trouve plus clair, plus simple et plus lisible.

Le fait de définir une telle énumération revient en fait à enrichir les types que nous avons à notre disposition, comme les entiers ou les chaines de caractères (int ou string). Ce nouveau type s’appelle « Jours ».

Nous pourrons définir une variable du type « Jours » de la même façon qu’avec un autre type :

Jours jourDeLaSemaine;

La seule différence c’est que les valeurs qu’il est possible d’affecter à notre variable sont figées et font partie des valeurs définies dans l’énumération.

Pour pouvoir accéder à un élément de l’énumération, il faudra utiliser le nom de l’énumération suivi de l’opérateur point « . » suivi encore de la valeur de l’énumération choisie. Par exemple :

Jours lundi = Jours.Lundi;
Console.WriteLine(lundi);

soit dans notre programme :

class Program
{
    enum Jours
    {
        Lundi,
        Mardi,
        Mercredi,
        Jeudi,
        Vendredi,
        Samedi,
        Dimanche
    }

    static void Main(string[] args)
    {
        Jours lundi = Jours.Lundi;
        Console.WriteLine(lundi);
    }
}

Ce qui nous donne :

Image utilisateur

Nous pourrons également nous servir des énumérations pour faire des tests de comparaisons, comme par exemple :

if (jourDeLaSemaine == Jours.Dimanche || jourDeLaSemaine == Jours.Samedi)
{
    Console.WriteLine("Bon week-end");
}

Sachez que le framework .NET utilise beaucoup les énumérations. Il est important de savoir les manipuler.

En résumé
  • Un tableau est un type évolué pouvant contenir une séquence d'autres types, comme un tableau d'entiers ou un tableau de chaînes de caractères.

  • Une liste est un type complexe un peu plus souple que le tableau permettant d'avoir une liste de n'importe quel type.

  • Une énumération s'utilise lorsque l'on veut créer un type possédant plusieurs valeurs fixes, comme les jours de la semaine.

Example of certificate of achievement
Example of certificate of achievement