C# : Les variables : Langage C#

Une variable ? qu'est-ce donc ?

Définition

Dans la plupart des langages de programmation dont C#, on utilise des variables. En C#, une variable est un nom associé à une valeur et possédant un type. Elle permet au programmeur de garder certaines valeurs en mémoire de façon à les réutiliser par la suite dans son programme.

Déclarer un variable

En C#, si je veux garder en mémoire l'âge d'un utilisateur, je pourrai une variable dont le nom est age, dont le type est un nombre entier et dont la valeur est 40, si l'utilisateur a 40 ans. En C#, créer une telle variable s'écrirait comme ceci :

int age = 40;

Cette instruction -car c'en est une, observez le point virgule à la fin de la ligne !- va libérer une nouvelle case dans la mémoire de votre ordinateur, y placer la valeur 40 et donner un nom à cette case qui sera age. De plus, notre ordinateur saura que cette variable est un nombre entier, car nous avons commencé notre instruction par le mot clé int, qui signifie entier en anglais (integer).

Créer une variable en informatique se dit Déclarer une variable. D'une manière générale, la déclaration de variable en C# se fait via la syntaxe suivante :

[type] [nom] = [valeur] ;

 

Intérêt des variables

On utilise les variables presque tout le temps quand on programme. Les variables sont utiles dans deux cas principaux et très fréquents :

1. Quand on connait une valeur et qu'on souhaite la réutiliser (quitte à la modifier) plusieurs fois dans un programme
       
2. Quand on ne connait pas a priori une valeur et qu'on a seulement accès à son nom de variable
 

 

Exemple d'usage : la réutilisation d'une valeur

Pour illustrer ces deux cas, nous allons créer un nouveau projet, que nous appellerons "Variables". Comme d'habitude, nous allons créer un nouveau dossier, appelé "Variables" et y initialiser notre projet C# avec

dotnet new console

Dans le fichier Program.cs généré nous allons retirer la ligne :

Console.WriteLine("Hello World!");

À la place, nous allons déclarer un variable ! Cette variable contiendra simplement le nom de notre programme. Notre programme s'appellera "Mon super programme sur les variables", créons une variable contenant cette valeur :

string programme = "Mon super programme sur les variables";

Nous déclarons un variable de type string (chaîne de caractères en français). Ce type de variable permet de stocker des mots ou des phrases de plusieurs lettres. Idéal pour stocker le nom de notre programme !

Affichons en console un message de bienvenue contenant le nom du programme !

static void Main(string[] args)
{
    string programme = "Mon super programme sur les variables";
    Console.Write("Bienvenue sur ");
    Console.WriteLine(programme);
}

Nous utilisons successivement Write et WriteLine pour afficher "Bienvenue sur " suivi du nom du programme. Write permet d'afficher un message sans revenir à la ligne ensuite, à la différence de WriteLine.

Maintenant, nous allons réutiliser notre variable dans la suite de notre programme. Continuons à ajouter du contenu à afficher.

static void Main(string[] args)
{
    string programme = "Mon super programme sur les variables";
    Console.Write("Bienvenue sur ");
    Console.WriteLine(programme);
    Console.Write("Sur ");
    Console.Write(programme);
    Console.WriteLine(" Nous verrons en détails ce que sont les variables !!");
}

Qui donne :

Vous voyez que nous utilisons deux fois la même variable. Quel est l'avantage de passer par un variable, me direz-vous ? On aurait pu réécrire la valeur cela aurait fonctionné tout aussi bien. Cela dit, nous pouvons maintenant changer le nom de notre application en ne modifiant qu'une seule valeur ! Ainsi, si nous voulons que notre titre devienne "Mon génialissime programme sur les variables", nous n'avons qu'à modifier les première ligne :

string programme = "Mon génialissime programme sur les variables";

Notre affichage sera modifié aux deux endroits.

Ainsi, nous examinons le premier cas d'utilisation d'une variable, la réutilisation d'une valeur jouant un rôle précis dans notre programme (en l'occurrence, son nom!)

Deuxième exemple d'usage : la récupération d'une valeur passée en paramètre

Il existe un deuxième cas où les variables sont utiles et même nécessaires. Pour comprendre ce cas, créons un nouveau programme, intitulé "Paramètres". Comme d'habitude, nouveau dossier "Paramètres" suivi de

dotnet new console

Dans ce programme, nous allons commencer à regarder ce qui se passe juste au dessus du code que nous étudions d'habitude, c'est-à-dire cette ligne

static void Main(string[] args)

Pour l'instant, nous ne ferons pas attention aux mots static void dont il n'est pas encore nécessaire de comprendre la signification. Concentrons-nous sur cette partie :

Main(string[] args)

Je n'entrai pas dans le détail ici (ce sera pour un autre chapitre) mais nous avons affaire à une déclaration de fonction. Cette fonction s'appelle Main, fonction principale, et c'est, comme vous le savez déjà, celle-ci qui est exécutée au démarrage de notre programme. Mais elle n'est pas seule ! Vous avez aussi, entre deux parenthèses... une variable ! Elle s'appelle args. et n'est pas déclarée mais passée en paramètre de la fonction. Sa valeur ne dépend pas de la fonction Main mais est définie avant.

Questions : Qu'est-ce que cette variable ? Comment est-elle définie ?

Pour le comprendre, nous allons utiliser un petit code, permettant d'afficher le contenu de cette variable.

static void Main(string[] args)
{
    Console.WriteLine(string.Join(", ", args));
}

Vous ne comprenez pas forcément ce code, mais ce n'est pas grave : gardez juste à l'esprit qu'il affiche le contenu de la variable args.

Si on lance le programme avec

dotnet run

, on obtient... rien.

Par contre, essayez pour voir de rajouter des mots après run :

dotnet run kikou lol

On obtient :

Notre programme affiche les mots ajoutés. La variable args contient donc les mots supplémentaires ajoutés après la commande par l'utilisateur qui écrit la commande

dotnet run

. Ces mots ne sont donc pas connus du programme a priori puisque entrés par l'utilisateur.

Une variable peut donc contenir une valeur que le programmeur ne connait pas au moment où il programme mais qui sera définie au moment de l'exécution dudit programme, comme c'est le cas de la variable args.

 

Les types de variables

Comme on l'a vu, une variable contenir n'importe quoi. Un nombre entier, une chaine de caractère, un nombre à virgule mais aussi des valeurs plus complexes. Dans le cas de args, par exemple, la variable contient une liste de mots (techniquement parlant : un tableau de chaine de caractères). C# range ces valeurs en différentes catégories ou types. Le type d'une variable dépendra donc de sa nature (ce que c'est).

Les nombres

Autant vous le dire tout de suite : un ordinateur n'est au fond qu'une grosse calculette très évoluée. Les types que l'ordinateur a le plus de facilité à manipuler sont les types numériques, qui représentent un nombre. En C#, on distingue en effet beaucoup de types de nombre. Le langage exige qu'on assez précis avec lui sur quel genre de nombre on souhaite déclarer : Entier ? Flottant ? Grand ? Très Grand ? En fonction de vos critères, vous ne déclarerez pas vos nombres en utilisant les mêmes types.

Type int et uint : les entiers de base

L'un des types les plus couramment utilisé en informatique est le int. Int signifie entier moyen. Un entier moyen est un entier dont la valeur maximale est 2147483648 (tout de même!) et dont la valeur minimale est -2147483648. Le nombre de valeur possibles pour le int est donc de, c'est-à-dire 2 puissance 32. Un int occupe donc un espace mémoire de 32 bits (ou 4 octets).

Si la variable que vous souhaitez utiliser est susceptible de varier entre ces deux valeurs (2147483648 et -2147483648), alors choisissez int.

Il existe aussi le uint qui va plus loin mais ne permet pas de choisir de valeur négative : entre 0 et 4294967296 seulement. Le u signifie d'ailleurs unsigned (sans signe -).

Exemples de déclaration :

int monEntier = -42;
uint monEntierNonSigne = 3174937226;

Type long et ulong

Moins souvent utilisés que le int, les longs sont des entiers aussi. Seulement, ce sont des entiers qui peuvent potentiellement être très... longs ! Les longs peuvent être compris entre -9223372037000000000 et 9223372037000000000 environ. Le choix est bien plus large que pour les int ! Pourquoi choisir des int, dans ce cas ? Simplement, parce que les longs occupent plus de place en mémoire (ils sont encodés sur 64 bits au lieu de 32). Par conséquent, si vous n'avez pas besoin d'entier très très grands, mieux vaut économiser la mémoire de votre ordinateur en déclarant des int.

Notez que le ulong suit le même principe que les uint, le panel est encore plus large mais uniquement dans les nombres positifs.

Pour distinguer les longs des ints, il est conseillé d'utiliser le suffixe L. Ce suffixe indique à l'ordinateur que l'entier est un long sans que ce dernier n'ait besoin de le deviner.

Exemples de déclaration :

long entierPasSiLong = 1234;
long entierLong = -65636395406435432L;
ulong entierTRESLONG = 5640395452354345345325313L;

Type short et ushort

Par opposition aux types longs, short et ushort permettent de déclarer des entiers courts. Ces entiers sont situés entre -32768 et 32767 et sont codés sur 16 bits. Ils se déclarent de le même façon que les int.

short entierCourt = 34;

Type sbyte et byte

Le type d'entier le plus restrictif : les byte, sont des entiers positifs et dont la valeur est obligatoirement comprise en 0 et 255. Les sbyte peuvent être positifs ou négatifs (signed byte), mais sont compris entre -128 et 127.

Type double

On peut aussi déclarer des nombres décimaux, autrement appelés nombres à virgule flottante. Le type double est l'un des types permettant d'accueillir un nombre décimal. Sa précision est très élevée (15-16 chiffres après la virgule). Le type double est le type de nombre permet de fournir le plus large panel de valeurs numériques. +/- 10 puissance 300 environ !

Exemples de déclaration :

double nbreDecimal = 5543.756;

Notez qu'en C#, un nombre décimal ne se note pas avec une virgule mais un point. N'essayez pas de les déclarer avec une virgule, cela de devrait pas marcher.

Type float

Le type float est un autre type de nombre à virgule flottante. Sa précision est moins élevée que celle du type double mais il occupe en contrepartie moins de place en mémoire. Cette particularité lui vaut d'être souvent préféré au double dans le domaine du jeux vidéo où la précision n'est pas forcément très importante.

Par défaut, C# considère qu'un nombre écrit avec une virgule est un double. Si vous souhaitez déclarer un float, vous devez utiliser le suffixe f ou F.

Exemples de déclarations :

float monFloat = 3.14f;
float monAutreFloat = -1.414F;

Type decimal

Dernier type de nombre décimal, le type... decimal. Celui-ci permet de stocker des nombres à virgule plus petits, mais avec une plus grande précision. La particularité des décimal est que plus le nombre est petit, plus sa précision peut être importante. Ce type est particulièrement utilisé dans des programmes exigeant une précision très importante comme les programmes liés à la finance. Pour déclarer un nombre décimal, vous devez le suffixer avec la lettre m :

decimal monDecimal = 4.32109876m;

 

Les caractères

Type char

Le type char permet de stocker des caractères, c'est à dire des lettres. Il est encodé sur 16 bits, et permet en théorie d'afficher plus de 64000 caractères différents (il en affiche moins que cela en réalité !). Pour déclarer un caractère, vous devez entourer la valeur de guillemets simples (simple quotes)

Exemples de déclaration :

char monCaractere = 'a';
char autreCaractere = '\u0123'; // déclaration à l'aide de la notation unicode
char encoreUnAutre = (char) 88; // conversion d'un int en char, donne '*'

Type string

Le type string permet de déclarer des chaines de caractères, c'est-à-dire des ensembles de plusieurs caractères à la suite (mots, phrases etc.) et est naturellement très souvent utilisé dans l'informatique moderne ! Pour déclarer ces chaines de caractères, vous devez les écrire entre double guillemets (double quotes).

Exemples de déclaration :

string mot = "Baobab";
string phrase = "Je suis le petit prince.";
string messageCrypteEtLouche = "FGFD#!dd$^lmaqHFFf:£";

Les booléens

Autre type un peu à part : les booléens. Ces types sont assez spéciaux dans la mesure où ils ne peuvent prendre que deux valeurs. Vrai ou faux (true ou false). Quel est l'intérêt me direz vous ? Vous verrez cela lorsque nous aborderons les conditions.

Exemples de déclaration :

bool conditionVrai = true;
bool conditionFalse = false;

Les objets

Nous en parlerons dans un autre chapitre. Les objets sont des structures complexes regroupant plusieurs valeurs de types différents au sein d'une même variable.

Les tableaux

Les variables peuvent également contenir des listes contenant un nombre déterminé d'éléments du même type. Ces listes sont appelées tableaux en C#. On peut créer des tableaux regroupant des valeurs quels types.

Un chapitre sera consacré aux tableaux. Pour l'instant, on se contente de dire qu'ils se déclarent avec des crochets [] et que les différentes valeurs listées sont comprises dans des accolades.

Exemples de déclaration :

int[] tableauxDEntiers = { 32, 64 } ; 
int[] autreTableauDEntiers = new int[2] { 32, 64 };
int[] tableauDeLongueur2SansValeurPrecisee = new int[2];

string[] tableauDeChaine = {"le C#", "!", "j'aime"};

float tableauDeFloat = new float[4] { 55f, 3.14F, 6.56f };

C'est tout pour la déclaration de variables. Dans un prochain chapitre, nous verrons ce que sont les branchements conditionnels.