Aller au menu - Aller au contenu

Icône Les variables

Par nico.pyright
Mise à jour : 02/02/2012
Difficulté : Facile Facile Creative Commons BY-NC-SA
22 955 visites depuis 7 jours, dont 709 sur ce chapitre classé 15/786
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.
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

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.

Le type correspond à ce que la variable représente : un entier, une chaine de caractères, une date, etc …


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# :

Code : C#
1
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 (« = »).

Code : C#
1
2
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 :

Code : C#
1
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 :

Code : C#
1
2
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 :

Code : C#
1
2
3
4
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.

Il est par contre possible d'utiliser des accents dans les noms de variable, cependant ceci n'est pas recommandé et ne fait pas partie des bonnes pratiques de développement. En effet, il est souvent recommandé de nommer ses variables en anglais (langue qui ne contient pas d'accents). Vous aurez noté que je ne le fais pas volontairement dans ce tutoriel afin de ne pas rajouter une contrainte supplémentaire lors de la lecture du code. Mais libre à vous de le faire :) .

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 :

Code : C#
1
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 :

Code : C#
1
2
3
4
int ageduvisiteur = 30;
int ageDuVisiteur = 20;
Console.WriteLine(ageduvisiteur); // affiche 30
Console.WriteLine(ageDuVisiteur); // affiche 20


A noter un détail qui peut paraitre évident, mais toutes les variables sont réinitialisées à chaque nouvelle exécution du programme. Dès qu’on démarre le programme, les classeurs sont vidés, comme si on emménageait dans des nouveaux locaux à chaque fois. Il est donc impossible de faire persister une information entre deux exécutions du programme en utilisant des variables. Pour ceci, on utilisera d’autres solutions, comme enregistrer des valeurs dans un fichier ou dans une base de données. Nous y reviendrons ultérieurement.
Retour en haut

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.

Code : C#
1
string prenom = "nicolas";


ou encore un décimal avec :

Code : C#
1
decimal soldeCompteBancaire = 100;


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

Code : C#
1
bool estVrai = true;


Il est important de stocker des données dans des variables ayant le bon type.

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.
Retour en haut

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 =.

Code : C#
1
2
int age = 30;
string prenom = "nicolas";


Note : dans ce paragraphe, je vais vous donner plusieurs exemples d’affectations. Ces affectations seront faites sur la même instruction que la déclaration pour des raisons de concision. Mais ces exemples sont évidemment fonctionnels pour des affectations qui se situent à un endroit différent de la déclaration.

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

Code : C#
1
int resultat = 2 * 3;


ou encore

Code : C#
1
2
3
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 :

Code : C#
1
2
3
4
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 :

Code : C#
1
2
3
4
5
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 :

Code : C#
1
2
3
4
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 :

Code : C#
1
2
3
4
5
6
int age = 20;
age = age + 10; // age contient 30 (addition)
age = age++; // age contient 31 (incrémentation de 1)
age = 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 :

Code : C#
1
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 :

Code : C#
1
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.

Attention, la division ici est un peu particulière.

Prenons cet exemple :

Code : C#
1
2
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 :

Code : C#
1
2
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.)

Le C# comprend qu'il s'agit de double car nous avons ajouté un .0 derrière. Sans ça, il considère que les chiffres sont des entiers.
Retour en haut

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 :

Code : C#
1
2
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 :

Code : C#
1
2
3
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 :

Code : C#
1
2
3
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 :

Code : C#
1
2
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 :

Code : C#
1
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 :

Code : C#
1
2
3
string sautDeLigne = "\n";
Console.WriteLine("Passer" + sautDeLigne + "à" +
        sautDeLigne + "la" + sautDeLigne + "ligne");


Dans ce cas, la variable sautDeLigne peut être remplacée par une espèce de variable qui existe déjà dans le framework .NET, à savoir Environment.NewLine.


Ce qui permet d’avoir le code suivant :

Code : C#
1
2
Console.WriteLine("Passer" + Environment.NewLine + "à" + 
                  Environment.NewLine + "la" + Environment.NewLine + "ligne");

permettant d’afficher :

Image utilisateur


Notez qu'il est possible de passer à la ligne lors de l'écriture d'une instruction C# comme je l'ai fait dans le dernier bout de code afin d'améliorer la lisibilité. N'oubliez pas que c'est le point-virgule qui termine l'instruction.


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.
Retour en haut

Q.C.M.

Quel est le nom de variable correct ?
Combien vaut la variable valeur ?

Code : C#
1
int valeur = 15 / 2;
Combien vaut la variable valeur ?

Code : C#
1
2
3
4
int valeur = 30/3;
valeur += 10 + 10 / 2;
valeur++;
valeur /= 2;
Quelle est l'écriture correcte ?
que vaut la variable test à la fin de ce code ?

Code : C#
1
2
3
int compte = 100;
bool test = compte > 10;
compte = 0;

Statistiques de réponses au QCM

Retour en haut

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.
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
3 commentaires pour "Les variables"
Note moyenne : 3.05 / 4 (230 votes)
Pseudo Commentaire
Hors ligne Helgrind444 # Posté le 05/04/2012 à 21:13:46
Avatar

Avis : Très bon

Très bon !
J'ai une petite question par contre, en ce qui concerne les Environment.Newline.
Pourquoi en mettre un dans un Console.WriteLine ?
Ce n'est pas plus pratique de faire ceci :
Console.WriteLine("Je \n passe \n une \n ligne")
?

Merci :)
Je sais mapper sur Source :D
HTML/CSS, c'est fait !
En route pour le C# !

Merci le SDZ ! :p
 
Hors ligne nico.pyright # Posté le 06/04/2012 à 08:52:54
Groupe : Auteurs

C'est presque pareil, c'est juste pour la culture

en fait, NewLine correspond à "\r\n"
Mon livre pour apprendre le C#
 
Hors ligne Helgrind444 # Posté le 08/04/2012 à 17:35:40
Avatar

Avis : Très bon

Merci de m'avoir répondu si vite :)
Je comprends mieux maintenant.
Je sais mapper sur Source :D
HTML/CSS, c'est fait !
En route pour le C# !

Merci le SDZ ! :p
 

Voir tous les commentaires