• 20 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Mis à jour le 14/08/2017

Les variables

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans ce chapitre nous allons apprendre ce que sont les variables et comment ces éléments indispensables vont nous rendre bien des services pour traiter de l'information susceptible de changer dans nos programmes informatiques.
Nous continuerons en découvrant les différents types de variables et nous ferons nos premières manipulations avec elles.

Soyez attentifs à ce chapitre, il est vraiment fondamental de bien comprendre à quoi servent les variables lors du développement d'une application informatique.

Qu’est-ce qu’une variable ?

Comme tous les langages de programmations, le C# va pouvoir conserver des données grâce à des variables. Ce sont en fait des blocs de mémoire qui vont contenir des nombres, des chaines de caractères, des dates ou plein d’autres choses.
Les variables vont nous permettre d’effectuer des calculs mathématiques, d’enregistrer l’âge du visiteur, de comparer des valeurs, etc.
On peut les comparer à des petits classeurs possédant une étiquette. On va pouvoir mettre des choses dans ces classeurs, par exemple, je mets 30 dans le classeur étiqueté « âge de Nicolas » et 20 dans le classeur « âge de Jérémie ». Si je veux connaitre l’âge de Nicolas, je n’ai qu’à regarder dans ce classeur pour obtenir 30. Je peux également remplacer ce qu’il y a dans mon classeur par autre chose, par exemple changer 30 en 25. Je ne peux par contre pas mettre deux choses dans mon classeur, il n’a qu’un seul emplacement.

Une variable est représentée par son nom, caractérisée par son type et contient une valeur.

Par exemple, l’âge d’une personne pourrait être stockée sous la forme d’un entier et accessible par la variable « age », ce qui s’écrit en C# :

int age;

On appelle ceci « la déclaration de la variable age ».

Le mot clé int permet d’indiquer au compilateur que la variable « age » est un entier numérique. int correspond au début d’ « integer » qui veut dire « entier » en anglais.

Ici, la variable « age » n’a pas été initialisée, elle ne pourra pas être utilisée car le compilateur ne sait pas quelle valeur il y a dans la variable age.

Pour l’initialiser (on parle également « d’affecter une valeur ») on utilisera l’opérateur égal (« = »).

int age;
age = 30;

Notre variable « age » possède désormais l’entier numérique « 30 » comme valeur.

L’initialisation d’une variable peut également se faire au même moment que sa déclaration. Ainsi, on pourra remplacer le code précédent par :

int age = 30;

Pour déclarer une variable en C#, on commence toujours par indiquer son type (int, ici un entier) et son nom (age). Il faudra impérativement affecter une valeur à cette variable avec l’opérateur « = », soit sur la même instruction que la déclaration, soit un peu plus loin dans le code, mais dans tous les cas, avant l’utilisation de cette variable.

Nous pouvons à tout moment demander la valeur contenue dans la variable age, par exemple :

int age = 30;
Console.WriteLine(age); // affiche 30

Il est possible de modifier la valeur de la variable à n’importe quel moment grâce à l’emploi de l’opérateur = que nous avons aperçu :

int age = 30;
Console.WriteLine(age); // affiche 30
age = 20;
Console.WriteLine(age); // affiche 20

Vous pouvez nommer vos variables à peu près n’importe comment, à quelques détails près. Les noms de variables ne peuvent pas avoir le même nom qu’un type. Il sera alors impossible d’appeler une variable int. Il est également impossible d’utiliser des caractères spéciaux, comme des espaces ou des caractères de ponctuation. De même, on ne pourra pas nommer une variable en commençant par des chiffres.

En général, une variable commence par une minuscule et si son nom représente plusieurs mots, on démarrera un nouveau mot par une majuscule. Par exemple :

int ageDuVisiteur;

C’est ce qu’on appelle le camel case.

Attention, suivant le principe de sensibilité à la casse, il faut faire attention car ageduvisiteur et ageDuVisiteur seront deux variables différentes :

int ageduvisiteur = 30;
int ageDuVisiteur = 20;
Console.WriteLine(ageduvisiteur); // affiche 30
Console.WriteLine(ageDuVisiteur); // affiche 20

Les différents types de variables

Nous avons vu juste au-dessus que la variable « age » pouvait être un entier numérique grâce au mot clé int. Le framework .NET dispose de beaucoup de types permettant de représenter beaucoup de choses différentes.

Par exemple, nous pouvons stocker une chaine de caractères grâce au type string.

string prenom = "nicolas";

ou encore un décimal avec :

decimal soldeCompteBancaire = 100;

ou encore un boolean (qui représente une valeur vraie ou fausse) avec

bool estVrai = true;

On ne peut par exemple pas stocker le prénom "Nicolas" dans un entier.

Les principaux types de base du framework .NET sont :

Type

Description

byte

Entier de 0 à 255

short

Entier de -32768 à 32767

int

Entier de -2147483648 à 2147483647

long

Entier de -9223372036854775808 à 9223372036854775807

float

Nombre simple précision de -3,402823e38 à 3,402823e38

double

Nombre double précision de -1,79769313486232e308 à 1,79769313486232e308

decimal

Nombre décimal convenant particulièrement aux calculs financiers (en raison de ses nombres significatifs après la virgule)

char

Représente un caractère

string

Une chaine de caractère

bool

Une valeur booléenne (vrai ou faux)

Vous verrez plus loin qu'il existe encore d'autres types dans le framework .NET et qu'on peut également construire les siens.

Affectations, opérations, concaténation

Il est possible d’effectuer des opérations sur les variables et entre les variables. Nous avons déjà vu comment affecter une valeur à une variable grâce à l’opérateur =.

int age = 30;
string prenom = "nicolas";

En plus de la simple affectation, nous pouvons également faire des opérations, par exemple :

int resultat = 2 * 3;

ou encore

int age1 = 20;
int age2 = 30;
int moyenne = (age1 + age2) / 2;

Les opérateurs « + », « * », « / » ou encore « - » (que nous n’avons pas encore utilisé) servent bien évidemment à faire les opérations mathématiques qui leur correspondent, à savoir respectivement l’addition, la multiplication, la division et la soustraction.
Vous aurez donc surement deviné que la variable « resultat » contient 6 et que la moyenne vaut 25.

Il est à noter que les variables contiennent une valeur qui ne peut évoluer qu’en affectant une nouvelle valeur à cette variable.
Ainsi, si j’ai le code suivant :

int age1 = 20;
int age2 = 30;
int moyenne = (age1 + age2) / 2;
age2 = 40;

la variable moyenne vaudra toujours 25 même si j’ai changé la valeur de la variable « age2 ». En effet, lors du calcul de la moyenne, j’ai rangé dans mon classeur la valeur 25 grâce à l’opérateur d’affectation « = » et j’ai refermé mon classeur. Le fait de changer la valeur du classeur « age2 » n’influence en rien le classeur « moyenne » dans la mesure où il est fermé. Pour le modifier, il faudrait ré-exécuter l’opération d’affectation de la variable moyenne, en écrivant à nouveau l’instruction de calcul, c’est-à-dire :

int age1 = 20;
int age2 = 30;
int moyenne = (age1 + age2) / 2;
age2 = 40;
moyenne = (age1 + age2) / 2;

L’opérateur « + » peut également servir à concaténer des chaines de caractères, par exemple :

string codePostal = "33000";
string ville = "Bordeaux";
string adresse = codePostal + " " + ville;
Console.WriteLine(adresse); // affiche : 33000 Bordeaux

D’autres opérateurs particuliers existent que nous ne trouvons pas dans les cours de mathématiques. Par exemple, l’opérateur ++ qui permet de réaliser une incrémentation de 1, ou l’opérateur -- qui permet de faire une décrémentation de 1.
De même, les opérateurs que nous avons déjà vus peuvent se cumuler à l’opérateur = pour simplifier une opération qui prend une variable comme opérande et cette même variable comme résultat.
Par exemple :

int age = 20;
age = age + 10; // age contient 30 (addition)
age++; // age contient 31 (incrémentation de 1)
age--; // age contient 30 (décrémentation de 1)
age += 10; // équivalent à age = age + 10 (age contient 40)
age /= 2; // équivalent à age = age / 2 => (age contient 20)

Comme nous avons pu le voir dans nos cours de mathématiques, il est possible de grouper des opérations avec des parenthèses pour agir sur leurs priorités.

Ainsi, l’instruction précédemment vue :

int moyenne = (age1 + age2) / 2;

effectue bien la somme des deux âges avant de les diviser par 2, car les parenthèses sont prioritaires.

Cependant, l’instruction suivante :

int moyenne = age1 + age2 / 2;

aurait commencé par diviser l’age2 par 2 et aurait ajouté l’age1, ce qui n’aurait plus rien à voir avec une moyenne. En effet, la division est prioritaire par rapport à l’addition.

Prenons cet exemple :

int moyenne = 5 / 2;
Console.WriteLine(moyenne);

Si nous l'exécutons, nous voyons que moyenne vaut 2.

2 ? Si je me rappelle bien de mes cours de math ... c'est pas plutôt 2.5 ?

Oui et non.
Si nous divisions 5 par 2, nous obtenons bien 2.5.
Par contre, ici nous divisons l'entier 5 par l'entier 2 et nous stockons le résultat dans l'entier moyenne. Le C# réalise en fait une division entière, c'est-à-dire qu'il prend la partie entière de 2.5, c'est-à-dire 2.

De plus, l'entier moyenne est incapable de stocker une valeur contenant des chiffres après la virgule. Il ne prendrait que la partie entière.

Pour avoir 2.5, il faudrait utiliser le code suivant :

double moyenne = 5.0 / 2.0;
Console.WriteLine(moyenne);

Ici, nous divisons deux « doubles » entre eux et nous stockons le résultat dans un « double ». (Rappelez-vous, le type de données « double » permet de stocker des nombres à virgule.)

Les caractères spéciaux dans les chaines de caractères

En ce qui concerne l’affectation de chaines de caractères, vous risquez d’avoir des surprises si vous tentez de mettre des caractères spéciaux dans des variables de type string.
En effet, une chaine de caractères étant délimitée par des guillemets " ", comment faire pour que notre chaine de caractères puisse contenir des guillemets ?

C’est là qu’intervient le caractère spécial \ qui sera à mettre juste devant le guillemet, par exemple le code suivant :

string phrase = "Mon prénom est \"Nicolas\"";
Console.WriteLine(phrase);

affichera :

Image utilisateur

Si vous avez testé par vous-même l’instruction Console.WriteLine  et enchainé plusieurs instructions qui écrivent des lignes, vous avez pu remarquer que nous passions à la ligne à chaque fois. C’est le rôle de l’instruction WriteLine  qui affiche la chaine de caractères et passe à la ligne à la fin de la chaîne de caractères.

Nous pouvons faire la même chose en utilisant le caractère spécial « \n ». Il permet de passer à la ligne à chaque fois qu’il est rencontré.
Ainsi, le code suivant :

string phrase = "Mon prénom est \"Nicolas\"";
Console.WriteLine(phrase);
Console.WriteLine("Passe\nà\nla\nligne\n\n\n");

affichera :

Image utilisateur

où nous remarquons bien les divers passages à la ligne.
Vous me diriez qu’on pourrait enchaîner les Console.WriteLine et vous auriez raison.

Mais les caractères spéciaux nous permettent de faire d’autres choses comme une tabulation par exemple grâce au caractère spécial « \t ». Le code suivant :

Console.WriteLine("Choses à faire :");
Console.WriteLine("\t - Arroser les plantes");
Console.WriteLine("\t - Laver la voiture");

permettra d’afficher des tabulations, comme illustré ci-dessous :

Image utilisateur

Nous avons vu que le caractère \ était un caractère spécial et qu’il permettait de dire au compilateur que nous voulions l’utiliser combiné à la valeur qui le suit, permettant d’ avoir une tabulation ou un retour à la ligne. Comment pourrons-nous avoir une chaine de caractères qui contienne ce fameux caractère ?

Le principe est le même, il suffira de faire suivre ce fameux caractère spécial de lui-même :

string fichier = "c:\\repertoire\\fichier.cs";
Console.WriteLine(fichier);

Ce qui donnera :

Image utilisateur

Pour ce cas particulier, il est également possible d’utiliser la syntaxe suivante en utilisant le caractère spécial @ devant la chaine de caractères :

string fichier = @"c:\repertoire\fichier.cs"; // contient : c:\repertoire\fichier.cs

Bien sur, nous pouvons stocker des caractères spéciaux dans des variables pour faire par exemple :

string sautDeLigne = "\n";
Console.WriteLine("Passer" + sautDeLigne + "à" +
        sautDeLigne + "la" + sautDeLigne + "ligne");

Ce qui permet d’avoir le code suivant :

Console.WriteLine("Passer" + Environment.NewLine + "à" + 
                  Environment.NewLine + "la" + Environment.NewLine + "ligne");

permettant d’afficher :

Image utilisateur

Environment.NewLine ? Une espèce de variable ? Qu’est-ce que c’est que cette chose là ?

En fait, je triche un peu sur les mots. Pour faciliter la compréhension, on peut considérer que Environment.NewLine  est une variable, au même titre que la variable « sautDeLigne » que nous avons défini. En réalité, c’est un peu plus complexe qu’une variable. Nous découvrirons plus loin de quoi il s’agit vraiment.

En résumé
  • Une variable est une zone mémoire permettant de stocker une valeur d'un type particulier.

  • Le C# possède plein de types prédéfinis, comme les entiers (int), les chaînes de caractères (string), etc.

  • On utilise l'opérateur = pour affecter une valeur à une variable.

  • Il est possible de faire des opérations entre les variables.

Exemple de certificat de réussite
Exemple de certificat de réussite