• Aucun résultat trouvé

C’est l’heure de faire la sélection des types les plus performants, place au casting ! Le jury est en place, à vos SMS pour voter. Ah, on me fait signe qu’il ne s’agirait pas de ce casting là … .

Le casting est simplement l’action de convertir la valeur d’un type dans un autre.

Plus précisément, cela fonctionne pour les types qui sont compatibles entre eux, entendez par là « qui se ressemblent ». Par exemple, l'entier et le petit entier se ressemblent. Pour rappel, nous avons :

Type Description

short Entier de -32768 à 32767

int Entier de -2147483648 à 2147483647

Ils ne diffèrent que par leur capacité. Le short ne pourra pas contenir le nombre 100000 par exemple, alors que l'int le pourra. Nous ne l'avons pas encore fait, mais le C# nous autorise à faire :

Code : C#

short s = 200;

int i = s;

Car il est toujours possible de stocker un petit entier dans un grand. Peu importe la valeur de s, i sera toujours à même de contenir sa valeur. C'est comme dans une voiture, si nous arrivons à tenir à 5 dans un monospace, nous pourrons facilement tenir à 5 dans un bus.

L'inverse n'est pas vrai bien sûr, si nous tenons à 100 dans un bus, ce n'est pas certain que nous pourrons tenir dans le monospace, même en se serrant bien.

Ce qui fait que si nous faisons : Code : C#

int i = 100000;

short s = i;

nous aurons l'erreur de compilation suivante : Code : Console

Impossible de convertir implicitement le type 'int' en 'short'. Une conversion explicite existe (un cast est- il manquant ?)

Et oui, comment pouvons-nous faire rentrer 100000 dans un type qui ne peut aller que jusqu'à 32767 ? Le compilateur le sait bien. Vous remarquerez que nous aurons cependant la même erreur si nous tentons de faire :

Code : C#

int i = 200;

short s = i;

Mais pourquoi ? Le short est bien capable de stocker la valeur 200 ?

Oui tout à fait, mais le compilateur nous avertit quand même. Il nous dit :

« Attention, vous essayez de faire rentrer les personnes du bus dans un monospace, êtes-vous bien sûr ? »

Nous avons envie de lui répondre :

« Oui oui, je sais qu'il y a très peu de personnes dans le bus et qu'ils pourront rentrer sans aucun problème dans le monospace. Fais moi confiance ! »

(on se parle souvent avec mon compilateur !)

Et bien, ceci s'écrit en C# de la manière suivante : Code : C#

int i = 200;

short s = (short)i;

Mais attention, le compilateur nous fait confiance. Nous sommes le boss ! Cela implique une certaine responsabilité, il ne faut pas faire n'importe quoi.

Si nous faisons : Code : C#

int i = 40000;

short s = (short)i; Console.WriteLine(s); Console.WriteLine(i);

nous tentons de faire rentrer un trop gros entier dans ce qu'est capable de stocker le petit entier. Si nous exécutons notre application, nous aurons :

Le résultat n'est pas du tout celui attendu. Nous avons fait n'importe quoi, le C# nous a punis.

En fait, plus précisément, il s'est passé ce qu'on appelle un dépassement de capacité. Nous l'avons déjà vu lors du chapitre sur les boucles. Ici, il s'est produit la même chose. Le petit entier est allé à sa valeur maximale puis a bouclé en repartant de sa valeur minimale.

Bref, tout ça pour dire que nous obtenons un résultat inattendu. Il faut donc faire attention à ce que l'on fait et honorer la confiance que nous porte le compilateur. Bien faire attention à ce que l'on caste.

Caste ... Remarquons cet anglicisme. Nous utiliserons souvent le verbe caster, qui signifiera bien sûr que nous convertissons des types qui se ressemblent entre eux, pour le plus grand malheur des professeurs de français.

D'une façon similaire à l'entier et au petit entier, l'entier et le double se ressemblent un peu. Ce sont tous les deux des types permettant de contenir des nombres. Le premier permet de contenir des nombres entiers, le deuxième pouvant contenir des nombres à virgules.

Ainsi, nous pouvons faire le code C# suivant : Code : C#

int i = 20;

double d = i;

En effet, un double est plus précis qu’un entier. Il est capable d’avoir des chiffres après la virgule alors que l’entier ne le peut pas. Ce qui fait que le double est entièrement capable de stocker toute la valeur d’un entier sans perdre d’information dans cette affectation.

Par contre, comme on peut s'y attendre, l’inverse n’est pas possible. Le code suivant : Code : C#

double prix = 125.55;

int valeur = prix;

produira l’erreur de compilation suivante : Code : Console

Impossible de convertir implicitement le type 'double' en 'int'. Une conversion explicite existe (un cast est- il manquant ?)

En effet, un double étant plus précis qu’un entier, si nous mettons ce double dans l’entier nous allons perdre notamment les chiffres après la virgule.

Il restera encore une fois à demander au compilateur de nous faire confiance !

« Ok, ceci est un double, mais ce n’est pas grave, je veux l’utiliser comme un entier ! Oui oui, même si je sais que je vais perdre les chiffres après la virgule ».

Ce qui s’écrit en C# de cette manière, comme nous l'avons vu : Code : C#

double prix = 125.55;

int valeur = (int)prix; // valeur vaut 125

Nous faisons précéder la variable prix du type dans lequel nous voulons la convertir en utilisant les parenthèses.

En l’occurrence, on peut se servir de ce cast pour récupérer la partie entière d'un nombre à virgule.

C'est plutôt sympa comme instruction. Mais n'oubliez-pas que cette opération est possible uniquement avec les types qui se ressemblent entre eux.

Par exemple, le cast suivant est impossible : Code : C#

string nombre = "123";

car les deux types sont trop différents et sont incompatibles entre eux. Même si la chaine de caractères représente un nombre. Nous verrons plus loin comment convertir une chaîne en entier. Pour l’instant, Visual C# Express nous génère une erreur de compilation :

Code : Console

Impossible de convertir le type 'string' en 'int'

Le message d’erreur est plutôt explicite. Il ne nous propose même pas d'utiliser de cast, il considère que les types sont vraiment trop différents !

Nous avons vu précédemment que les énumérations représentaient des valeurs entières. Il est donc possible de récupérer l’entier correspondant à une valeur de l’énumération grâce à un cast.

Par exemple, en considérant l’énumération suivante : Code : C#

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

}

Le code suivant : Code : C#

int valeur = (int)Jours.Lundi; // valeur vaut 5

convertit l’énumération en entier.

Nous verrons dans la prochaine partie que le cast est beaucoup plus puissant que ça, mais pour l’instant, nous n’avons pas assez de connaissances pour tout étudier. Nous y reviendrons dans la partie suivante.