Aller au menu - Aller au contenu

Icône Tableaux, listes et énumérations

Par nico.pyright
Mise à jour : 02/02/2012
Difficulté : Intermédiaire Intermédiaire Creative Commons BY-NC-SA
22 955 visites depuis 7 jours, dont 688 sur ce chapitre classé 15/786
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
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

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 :

Code : C#
1
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 plus tard ; 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 [] :

Code : C#
1
2
3
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

Attention, le premier élément du tableau se situe à l’indice 0 et le dernier se situe à l’indice « taille du tableau – 1 », c'est-à-dire 6 dans notre exemple. Si on tente d’accéder à un indice qui n’existe pas, l’application lèvera une erreur.

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

Code : C#
1
2
3
4
5
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 :

Code : C#
1
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 :

Code : C#
1
2
3
4
5
6
7
8
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 :

Code : C#
1
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 :

Code : C#
1
2
3
4
5
6
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.
Retour en haut

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 :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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.

Comme les tableaux, le premier élément de la liste commence à l’indice 0.

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 un prochain chapitre. 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 :

Code : C#
1
2
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 :

Code : C#
1
2
3
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.

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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 les chapitres suivants.

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 un chapitre ultérieur. 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 :

Code : C#
1
2
3
4
5
6
7
8
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

Code : C#
1
List<string> jours = new List<string> { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };

un peu comme pour les tableaux.
Retour en haut

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.
Retour en haut

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 :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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 :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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 :

Code : C#
1
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 :

Code : C#
1
2
Jours lundi = Jours.Lundi;
Console.WriteLine(lundi);

soit dans notre programme :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
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 :

Code : C#
1
2
3
4
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.

Vous aurez peut-être remarqué que lorsqu'on affiche la valeur d'une énumération, la console nous affiche le nom de l'énumération et non pas sa valeur entière. Ça peut paraître étrange, mais c'est parce que le C# fait un traitement particulier dans le cadre d'une énumération à l'affichage.

Retour en haut

Q.C.M.

Quelle est la syntaxe correcte ? Sachant que tableau est un tableau d'entier.
Quelle est la syntaxe équivalente à

Code : C#
1
2
3
4
int[] tableau = new int[3];
tableau[0] = 1;
tableau[1] = 2;
tableau[2] = 3;
A quel indice démarre un tableau ?
Quelle est la capacité d'une liste ?
Quelle est la valeur entière de Mercredi ?

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
enum Jours
{
    Lundi,
    Mardi = 10,
    Mercredi,
    Jeudi,
    Vendredi,
    Samedi,
    Dimanche
}

Statistiques de réponses au QCM

Retour en haut

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.
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
11 commentaires pour "Tableaux, listes et énumérations"
Note moyenne : 3.05 / 4 (230 votes)
Pseudo Commentaire
Hors ligne Bakomen # Posté le 24/11/2011 à 18:13:43
Avatar

 alut, j'ai un problème au niveau des listes. J'utilise monodevelop sur ubuntu (j'ai pas Windows trop cher) . le truc c quand je déclare une variable de type liste, au moment de la compilation je tombe j'ai un message tu genre Code : Console - Sélectionner

Code : Console
the type or namespace name 'List 1 could not be found. Are you missing a using directive or an assemblu reference ?




J'aimerais savoir si un utilisateur de monodevelop a déjà été confronté à ce problème.

Merci bien ;)
                    
                		
                

              
                

                  
                    
                      Connecté 
                    
                      Gugelhupf
                    
                  
                  
                    #
                    
                         Posté le 02/01/2012 à 22:51:12
                    
                    
                


                
                    

                
                
                    

Avatar



    





                		
                
                    
                    Bonsoir,



Tout d'abord je tiens à remercier l'auteur ou les auteurs de ce tutoriel.



Il manque une chose essentiel à cette partie du tutoriel, ce sont les tableaux multi-dimensionnels, il serait vraiment bien d'y mettre un petit exemple, ne serait-ce qu'avec un tableau à 2 dimensions.





Autrement comme dit dans un message au-dessus, il existe une syntaxe plus courte pour les tableau :

Code : C#
1
string[] jours = new string[] { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };







Qui est :

Code : C#
1
string[] jours = { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };







Il serait vraiment bien d'ajouter cette syntaxe alternative dans le cours et de préciser s'il y a une différence notable.
                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      nico.pyright
                    
                  
                  
                    #
                    
                         Posté le 03/01/2012 à 14:13:15
                    
                    
                


                
                    

                
                
                    


            Groupe : Auteurs
        


    





                		
                
                    
                    Bonjour et merci de ta remarque,



j'avais commencé à faire une partie sur les tableaux à 2 dimensions et puis finalement j'ai tout supprimé car je pense que ce n'est pas nécessaire. Rares sont les fois où j'utilise des tableaux à deux dimensions, à part dans des calculs de matrices, et encore, des objets sont plus adaptés.



Donc c'est un choix de pas le mettre :)
                    
                        
Mon livre pour apprendre le C#

                        
 

                    
                		
                

              
                

                  
                    
                      Connecté 
                    
                      Gugelhupf
                    
                  
                  
                    #
                    
                         Posté le 03/01/2012 à 14:58:25
                    
                    
                


                
                    

                
                
                    

Avatar



    





                		
                
                    
                    Houlala  :o 



Le fait d'indiquer qu'il existe des tableaux multidimensionnels en C#, accompagné d'un petit exemple (un tableau à 2 dimensions) c'est une chose à savoir qui est tellement basique que de ne pas en être au courant est très grave.



Tu prends n'importe quel tutoriel de langage présent sur ce site, tu y verras forcément un exemple de tableaux à 2 dimensions.



Ce qu'il serait intéressant de noter, c'est la syntaxe des tableaux multidimensionnel en C# :

Code : C#
1
2
3
4
int[,] tabDeuxDimensions = new int[ 32, 16 ]; // Déclaration

// un tableau de 32*16 entiers, soit 512 entiers
tabDeuxDimensions [1,5] = 0; // Initialisation coordonnée 1, 5







Un tableau à 2 dimensions avec initialisation :

Code : C#
1
2
// Déclaration avec initialisation
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };









Un dernier petit point, qui peut paraître négligeable, mais tu pourrais ajouter le fait qu'il ne faut pas confondre avec Visual Basic .NET, où le premier indice d'un tableau en C# commence à 0 et non pas à 1 comme en VB, mais ce n'est qu'un mini détail.
                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      king2012
                    
                  
                  
                    #
                    
                         Posté le 07/04/2012 à 13:04:48
                    
                    
                


                
                    

                
                
                    


    

    Avis : Très bon
        
    



    





                		
                
                    
                    Bonjour,



Pour utiliser les listes, il faut ajouter la ligne suivante au début du fichier Program.cs :



Code : C#
1
using System.Collections.Generic;




                    
                		
                

              
            
        

        
            
Voir tous les commentaires