Langage C Sharp/Les types

{{Chapitre |niveau=15

 | idfaculté= informatique
 | numéro    = 3  | précédent = Premier programme

|suivant=Les instructions élémentaires Le langage C# est langage fortement typé, ainsi chaque valeur possède un type qui la restreins leur utilisation dans l'environnement d'exécution. En C# il y a 2 familles de types, les types references et les types valeurs, les premiers sont alloué dans la parti de la mémoiré appelé "Tas", les seconds sont alloués sur la "Pile".

Les types valeurs de base

Il existe plusieurs catégories de types :

• Le type booléen bool dont les seules valeurs sont true (vrai) et false (faux)
• Les types numériques entiers signés (positifs ou négatifs) :
  • Le type sbyte (8 bits), ex: -10, 0, 120
  • Le type short (16 bits), ex: -1000, 10
  • Le type int (32 bits)
  • Le type long (64 bits)
• Les types numériques entiers non signés (positifs) :
  • Le type byte (8 bits), ex: 0, 120, 255
  • Le type ushort (16 bits)
  • Le type uint (32 bits)
  • Le type ulong (64 bits)
• Les types numériques flottants :
  • Le type float (32 bits), ex: 0.2, 3.14159
  • Le type double (64 bits)
  • Le type decimal (128 bits)
• Le type caractère unicode char (au minimum 16 bits), ex: 'A', '*'

Déclaration d'une variable

Une variable est déclarée en lui attribuant un type suivi d'un nom.

Exemple : Pour déclarer une variable de type entier nommée "total" :

int total;

Une fois la variable déclarée, il est possible de l'utiliser :

• Stocker une valeur en utilisant un opérateur d'affectation,
• Lire la valeur stockée en faisant référence à la variable (son nom).

Exemple (suite) :

total = 10; // Stocker une valeur
System.Console.WriteLine("Le total vaut " + total); // Lire la valeur et l'afficher

Entre la déclaration et la première affectation d'une variable, celle-ci n'est pas initialisée (ne possède pas de valeur explicite). Il est possible de combiner déclaration et affectation initiale.

Exemple :

int total = 10; // Variable initialisée à la déclaration
System.Console.WriteLine("Le total vaut " + total); // Lire la valeur et l'afficher

Les expressions

Les expressions utilisent différents opérateurs (addition, soustraction, concaténation, ...) qui ne s'appliquent qu'aux types qui ont surchargé ces operateurs.

L'opérateur +

L'opérateur + permet d'additionner deux nombres (entiers ou flottants).

Exemples :

• 10 + 5
• 2.3 + 1.7
• 10 + 2.8

Lors d'une operation de deux types différents, un des deux types va être casté en l'autre type. Biensure a condition que l'operation soit possible pour les deux types et que l'un d'eux possède une regle de cast implicite pour le type suivant.

L'opérateur + permet également de concaténer deux chaînes de caractères :

• "Un " + "exemple" // → "Un exemple"

et de concaténer une chaîne de caractère à une valeur d'un autre type. Dans ce cas, cette valeur est convertie en chaîne de caractères avant de la concaténer à la chaîne de caractère spécifiée.

• "Le total vaut " + 10 // → "Le total vaut 10"

Premier programme interactif

Prenons notre programme "Bonjour le monde" précédemment effectué. Jusqu'à présent, entre le début et la fin du programme, on ne peut pas influencer son exécution. La méthode "Console.ReadLine();" prend en note tout ce que vous lui inscrivez au clavier sous forme de chaine de caractère, jusqu'au charactere de retour a la ligne. Pour prendre en note le résultat, il suffit de le déposer dans une variable de type string.

Une salutation plus personnelle

De plus, le programme salue inutilement un nombre important de gens (le monde!) alors que vous êtes probablement seul devant votre écran. Le programme pourrait tout d'abord vous demander votre nom, puis ensuite ne saluer que vous, par exemple. Voici à quoi pourrait ressembler la source une fois modifiée:

using System;

public class Bonjour
{
    public static void Main()
    {
        string Nom;
        Console.Write("Inscrivez votre nom: ");
        Nom = Console.ReadLine();
        Console.WriteLine("Bonjour " + Nom + " !");
    }
}

Explorons pas a pas les nouveautés de se code source:

        string Nom;

Ici, nous déclarons la variable afin de pouvoir l'utiliser plus tard. Prenez note qu'à ce moment, la variable est déclarée mais n'est pas initialisée. Elle possède donc la valeur null. Remarquez qu'ici la déclaration est détachée de son utilisation, mais il aurait été tout a fait possible de faire les deux sur la même ligne grâce a l'opérateur d'assignation =.

        Nom = Console.ReadLine();

Ici nous initialisons enfin notre variable en prenant pour valeur le résultat de la fonction ReadLine() de la classe Console. La variable nom contiendra donc tout ce que l'usager aura écrit avant d'appuyer sur "Enter".

        Console.WriteLine("Bonjour " + Nom + " !");

Finalement, nous affichons la salutation personnalisée à l'usager en utilisant le + comme opérateur de concaténation. Prenez note que l'utilisation d'une chaine formatée Console.WriteLine("Bonjour {0}!", Nom); serait préférable mais je doute que ce soit un réel problème à se stade-ci!

Un additionneur rudimentaire

Eh voila, vous venez de réussir votre premier programme interactif. Mais, vous en conviendrez, il ne fait pas grand chose. Pourquoi ne pas lui donner un minimum d'utilité (j'insiste alors sur le mot "minimum"). Calculons l'addition de deux nombres entiers.

using System;

public class HelloWorld
{
    public static void Main()
    {
        string Nom;
        int Nombre1, Nombre2, Resultat;

        Console.Write("Inscrivez votre nom: ");
        Nom = Console.ReadLine();

        Console.Write("Inscrivez le premier nombre entier: ");
        Nombre1 = int.Parse(Console.ReadLine());

        Console.Write("Inscrivez le second nombre entier: ");
        Nombre2 = int.Parse(Console.ReadLine());

        Resultat = Nombre1 + Nombre2;

        Console.WriteLine("Bonjour " + Nom + " ! L'additionneur vous informe que le calcul est le suivant:");
        Console.WriteLine(Nombre1 + "+" + Nombre2 + "=" + Resultat);
    }
}

Explorons pas a pas les nouveautés de se code source:

        int Nombre1, Nombre2, Resultat;

Comme vous pouvez le remarquer, il est possible de déclarer plusieurs variables de même types sur la même ligne, en utilisant la virgule comme séparateur. Un entier non initialisé contient normalement la valeur zéro, mais il est déconseiller de prendre cela comme une convention.

        Nombre1 = int.Parse(Console.ReadLine());

Comme dit précédemment, Console.ReadLine() retourne une chaine de caractère. Malheureusement, pour les calculs, c'est peu utile. Du coup, la fonction Parse() du type int (et autres types numeriques) permet de transformer une chaine de caractère en entier. Prenez note que cette fonction s'attend de recevoir une chaine valide et lèvera une exception si jamais la chaine ne contient pas que des chiffres.