Chapitre 5 : Plus sur les variables

What we will learn in this chapter

 Comment faire des conversions implicites et explicites entre

différents types de données
 Comment créer et utiliser les types enum
 Comment créer et utiliser les types struct
 Comment créer et utiliser les tableaux
 Comment manipuler les strings ou chaînes de caractères

Type de conversion

Il existe deux types de conversion :

 Implicite

La conversion depuis un type A vers un type B est possible en toutes circonstances, et les
règles de conversion sont assez simples pour faire confiance au compilateur

 Explicite

La conversion depuis un type A vers un type B est seulement possible dans certaines
circonstances

Conversion Implicite

Elle ne requiert aucun travail de votre part et pas de codes additionnels. Considérons le code
ci-dessous :

var1 = var2 ;

Cet exemple peut conduire à la conversion implicite du type de var2 vers le type de var1,
cependant si les deux variables sont du même type, aucune conversion implicite n’est requise.

Exemple :
Affichage

On voit dans cet exemple qu’il y a une conversion implicite et que le caractère « a » est
convertit en « 97 »

Conversion explicite
Comme son nom l’indique, une conversion explicite a lieu quand vous demandez
explicitement au compilateur de convertir une valeur depuis un type de donnée vers un autre.

Ces conversions ont besoin de codes extra, et le format de ces codes peuvent varier,
dépendant de la méthode exacte de conversion.

Exemple :

Si nous prenons le dernier exemple, avec types de données comme byte et short, le
compilateur ne pourra pas exécuter le programme.
On a cette erreur qui s’affiche tout en bas :

Pour pouvoir compiler ce code, il nous faut donc une conversion explicite. La méthode la plus
simple pour faire cette conversion dans ce contexte est des caster (convertir) le type « short »
en « byte ». Le casting en gros consiste à forcer la conversion d’un type vers un autre, et il
utilise la syntaxe suivante :

(<type de destination>)<variable source>

Exemple :

destinationVar = (byte)sourceVar ;

Conversions explicites avec la commande « Convert »

Exemple :
Les types de variables complexes

En plus des types de variables simples, le langage C# dispose de trois autres types de
variables complexes qui sont très utiles :

 Enumerations (souvent appelés enums)

 Structs (souvent appelés structures)
 Arrays (tableaux)

Enumerations

Tous les types de variables que nous avons vus dans ce cours à l’exception du type « string »,
ont tous un ensemble de valeurs autorisées. Par exemple le type « bool » ne peut prendre que
« true » ou « false ».

Il peut arriver que l’on ait besoin d’une variable qui peut prendre une valeur parmi un
ensemble de valeurs fixes. Par exemple on pourrait avoir besoin d’une variable « orientation »
qui peut prendre à un moment donné l’une des valeurs suivantes : nord, sud, est, ou ouest.

Dans une situation comme celle-ci les enumerations peuvent être très utiles.

Elles définissent un type qui peut prendre un ensemble fini de valeurs que vous fournissez. Ce
que l’on a à faire ensuite c’est de créer notre type d’enumeration qui peut prendre l’une des
valeurs que nous définissons.

Définition des enumerations

1. On utilise le mot clé « enum » suivi du nom du type

2. On peut déclarer des variables avec le type que l’on vient de définir

3. On peut assigner des valeurs à ces variables

Pour stocker les valeurs contenues dans les enumerations, le type utilisé par défaut est « int ».

On peut cependant changer ce type avec d’autres comme byte, sbyte, short, ushort, uint, long
et ulong.
Déclaration du type de stockage :

< underlyingType > : type de stockage qui définit le type de l’énumération

Ici, value1 reçoit la valeur 0, value2 reçoit et ainsi de suite.

On peut aussi changer ces valeurs en utilisant l’opérateur d’assignation =

Exemple : byte : 0 à 255

Modifions le code et ajoutons-y ceci :

Structs

Les structures sont composées de plusieurs pièces de données, qui peuvent être de types
différents. Supposons que nous voulons définir une route pour atteindre une destination en
partant d’un point A, cette route comprend une direction et une distance en kilomètres.

Nous pouvons utiliser « orientation » l’enumeration de tout à l’heure pour caractériser la

direction et la distance qui peut être représentée par une variable de type double.

On pourrait utiliser deux variables comme nous l’avions toujours fait :

Il n’y a rien d’anormal dans l’utilisation de ces deux variables, sauf que si nous avons
plusieurs directions, le travail devient fastidieux.

Définition d’une structure

On définit une structure en utilisant le mot clé « struct »

< memberDeclaration > représente les données de la structure.

Pour déclarer une donnée d’une structure on utilise la syntaxe ci-dessous :

Afin de permettre au code qui appelle la structure d’accéder à ses données on utilise le mot clé
« public » à la place d’ « accessibility »

Exemple :

Une fois que l’on a défini notre structure, on déclare une variable du type de la structure

On peut ainsi accéder aux données de la structure.

Exemple :
Arrays (les tableaux)

Tous les types que nous avons vu plus loin ont quelque chose en commun : chacun d’eux
stocke une seule valeur (ou un seul ensemble de valeurs dans le cas des structures). Parfois, il
peut arriver que l’on veuille stocker plusieurs données, cela n’est pas trop convenable.

Vous pouvez vouloir stocker plusieurs valeurs d’un même type à un moment donné, sans
vouloir déclarer une variable pour chaque valeur.

Par exemple, on voudrait stocker les différents noms des étudiants de LP2, on peut le faire
ainsi :

Ce ci devient fastidieux si l’on a 1000 étudiants.

L’alternative est d’utiliser les tableaux. Le tableau comprend des indexes représentant les
valeurs contenues dans ce dernier.

Exemple : friendNames[index]

[index] : représente un entier, sa première valeur est 0

Pour afficher le contenu d’un tableau on utilise une boucle

Déclaration d’un tableau

On déclare un tableau de la manière suivante :

Déclaration et initialisation (deux méthodes)

// On initialise

// On initialise et on donne la taille

Combinaison des deux méthodes

Exemple :

Parcourir un tableau avec « foreach »

Syntaxe :

Exemple :
Tableaux Multidimensionnels

Un tableau multidimensionnel est un tableau qui utilise plusieurs indices pour accéder à ses
éléments.

Par exemple, supposons que l’on veuille déterminer la hauteur d’une montagne par rapport à
une position mesurée. La position est définit par les cordonnées x et y.

On veut utiliser x et y comme indices de telle sorte que l’on ait un tableau qui stocke la
hauteur grâce à la paire x et y.

Cela implique l’utilisation d’un tableau multidimensionnel.

Un tableau à deux dimensions est ainsi déclaré :

Un tableau à plusieurs dimensions requiert plusieurs virgules :

Ici on déclare un tableau à quatre dimensions.

Déclaration et initialisation d’un tableau à deux dimensions :

3 : représente x le n° de la ligne

4 : représente y le contenu de la ligne

Assignation des valeurs :

Dans ce tableau nous avons trois lignes et quatre colonnes

Pour accéder à chaque élément d’un tableau on utilise ses indices :

Utilisation de foreach :

Ex :
static void Main(string[] args)
{
double[,] hillheight = new double[3, 4] {{1,2,3,4},{2,3,4,5},{3,4,5,6} };
foreach (double height in hillheight)
{
Console.WriteLine("{0}", height);
}
Console.ReadKey();
}