Si vous débutez en développement logiciel, vous avez sûrement déjà rencontré ce concept : les variables. Mais qu’est-ce qu’une variable ?

 

Qu’est-ce qu’une variable ?

C’est une sorte de boîte, étiquetée, où l’on peut stocker de l’information pour la consulter ou la modifier plus tard.

La programmation est basée sur ces deux concepts nécessaires, les variables et les instructions. Sans eux, rien ne serait possible.

Les variables correspondent aux récipients utilisés dans une recette et les instructions aux différentes étapes de la recette. En suivant les étapes de la recette, les instructions du programme, nous manipulons des aliments dans les récipients, ce qui correspond aux données que nous mettons dans les variables. Ces manipulations vont faire évoluer les aliments en quelque chose de nouveau.

Dans les recettes, la chimie permet de transformer les aliments en un produit fini tout nouveau, avec une texture et un comportement spécifique. En programmation, ce sont les mathématiques qui vont jouer ce rôle de transformateur sur les données dans les variables. À vous de choisir vos instructions avec soin pour obtenir les bonnes transformations et aller vers le résultat attendu.

 

Comment est stockée une variable ?

OK, ce sont des boîtes étiquetées, et nous pouvons mettre des informations dedans, consulter ces informations et même les modifier. Voici un exemple dans le cadre de la location d’un gîte :

Mais où sont ces boites dans mon ordinateur ? Dans la RAM :

Ces boites sont stockées dans la mémoire vive de l’ordinateur, c’est-à-dire les barrettes de RAM.
RAM signifie Rapide Access Memory, ou Mémoire à Accès Rapide en français.
Tout le monde parle de RAM.

Schématiquement la mémoire vive ressemble à un long ruban contenant un grand nombre de cases contiguës :

Chacune de ces cases a une adresse, que l’on appelle l’adresse mémoire. Ici j’ai présenté la mémoire aux adresse 243 à 250. Pour faire simple, j’ai pris des petites adresses. Sachez que les adresses mémoires sont en général bien plus grande.

Ces cases sont en fait l’unité de base d’une boite étiquetée. Les valeurs des variables sont stockées dans ces cases. Par exemple :

Et l’étiquette alors ? L’ordinateur fonctionne uniquement avec des nombres, non pas avec des étiquettes. L’étiquette n’existe pas directement dans la RAM. L’étiquette correspond à une adresse mémoire, qui elle-même correspond à une case de la RAM.

Ainsi, toujours avec le même exemple, l’équivalence entre les étiquettes et les adresses serait :

Variable “prix à la semaine” à l’adresse 249.
Variable “ville” à l’adresse 244.
Variable “Nombre de chambres” à l’adresse 248.
Variable “code postal” à l’adresse 289.
Variable “Surface” à l’adresse 243.

Cela peut se représenter ainsi en RAM :

J’ai mélangé l’ordre des variables pour bien vous faire toucher du doigt que l’ordre n’est absolument pas garanti ! Le système pourrait même vous attribuer des bouts de mémoire qui ne se suivent pas !

Ainsi, quand nous demandons à lire le contenu de la variable surface, l’ordinateur sait que l’étiquette surface correspond à l’adresse mémoire 243. La lecture revient donc à lire le contenu de la case mémoire 243, c’est à dire la valeur 432.

Cette astuce nous permet de travailler avec des étiquettes dans nos algorithmes alors que l’ordinateur lui fonctionne uniquement avec des chiffres : les adresses mémoires.

 

Qu’est-ce que le type d’une variable ?

Pour reprendre ma comparaison en début d’article, le type de variable est un peu comme le type des récipients. Chaque récipient appartient à une grande famille. Il y a les saladiers, les poêles, les faitouts, etc.
Chaque famille de récipient s’utilise d’une manière qui lui est propre, offre des services spécifiques.

Retenez qu’une variable va être limitée en fonction de son type tout comme un récipient est limité en fonction de sa famille.

Par exemple vous aurez beaucoup de difficulté à monter des blancs en neige dans une poêle.

De même, je peux additionner des nombres, pas des caractères.
Enfin, dans les faits cela dépend du langage que vous utilisez. J’entre plus dans les détails ci-dessous.

Il y a 4 grands types en programmation :

• les nombres entiers
• les nombres flottants, c’est-à-dire les nombres avec une virgule
• les chaines de caractères
• les booléens

Sachez qu’il existe une certaine diversité pour chacun de ces types, pour chaque langage. Vous devez regarder les caractéristiques de votre langage pour connaitre les types existants et leurs caractéristiques.

Par exemple, voici les sous-types entiers les plus courants et leurs correspondances dans plusieurs langages à typage fort :

Type	Taille	Plage	En Java	En C#	En C++
Entiers très courts	1 octet (8 bits)	-128 à 127	byte	sbyte	char
Entiers courts	2 octets (16 bits)	-32 768 à 32 767	short	short	short (*)
Entiers	4 octets (32 bits)	-2 147 483 648 à 2 147 483 647	int	int	int (*)
Entiers longs	8 octets (64 bits)	-9 223 372 036 854 775 808 à 9 223 372 036 854 775 807	long	long	long (*)

(*) ces types ont la particularité d’être au moins de cette taille là. Ils peuvent être plus grand selon la machine.

 

J’ai mis ici les versions signées. Sachez que le signe prend 1 bit de place, c’est autant que l’on ne peut pas stocker comme information. Il existe aussi des versions non signées qui permettent de stocker de plus grand nombre, grâce au bit de signe récupéré pour stocker de l’information. Je ne les détaille pas ici.

 

Typage fort vs typage faible

Sans trop partir dans les détails, je fais un aparté sur ce sujet que vous ne pouvez pas ignorer.

Les langages ne fonctionnent pas tous de la même manière par rapport aux types et à ce que l’on peut faire avec. Il y a deux grandes catégories :

• les langages à typage fort,
• les langages à typage faible.

Quand le typage est fort, tout ce que je vous ai expliqué jusqu’ici est vrai.

Quand le typage est faible, la très grande différence est que vous pouvez faire changer le type de votre variable à la volée, selon vos besoins.

Vous pourriez trouver cela utile, et ça l’est dans certains cas. Cependant…

“Un grand pouvoir implique de grandes responsabilités”

Ben Parker (Spiderman).

En fait, cette possibilité vous permet de faire plus de choses plus facilement et vous oblige à être sûr de ce que vous faites. Vous avez moins de garde-fous.

Le langage ne vous aidera pas à détecter les erreurs d’inattention où vous tentez de manipuler la mauvaise variable. Il va croire votre code tel quel et tenter de comprendre ce que vous voulez qu’il fasse. Cela donne souvent des surprises, donc des bugs, dont l’origine peut être difficile à retrouver.

Si vous débutez en programmation, je vous recommande de rester sur un langage à typage fort. Vous avez déjà beaucoup de choses à découvrir et à apprendre sans vous ajouter des embuches pour le plaisir.

 

Pour votre information, je livre ici une version simplifiée des typages forts et faibles destinée à des débutant.

 

Comment utiliser les variables ?

OK, les variables sont des étiquettes correspondant à une boite où stocker des informations. Cette boîte est en fait une zone de la mémoire RAM. L’étiquette correspond à l’adresse mémoire de cette zone.

Comment peut-on nommer les variables ?

Les noms possibles dépendent du langage que vous utilisez. Je vous laisse regarder la documentation de votre langage pour en savoir plus.

En général les noms des variables doivent respecter les règles suivantes :

• commencer par un caractère ou le signe _
• contenir des caractères, des chiffres ou des signes _
• ne pas contenir de caractère spécial, notamment pas d’espace
• ne pas être un mot réservé

Pour utiliser une variable, nom commençons par lui donner un nom et un type, cela s’appelle une déclaration.

 

Comment lire et modifier une variable ?

Nous savons maintenant ce qu’est une variable et à quoi cela sert : une zone mémoire avec un nom, capable d’être lue et modifiée à l’envie.

Comment mettre une valeur dans une variable ? Cela s’appelle une affectation.

En pseudo-code, nous mettons une valeur avec la ligne suivante :

age <- 24;

La flèche permet d’être clair sur ce qui se passe, ici la valeur 24 va dans la variable âge.

C’est notamment utile si nous utilisons d’autres variables comme ici :

ageMoyen <- (ageMere + agePere + ageEnfant1 + ageEnfant2) / 4 ;

La variable ageMoyen prend comme valeur le résultat du calcul de la moyenne des âges des membres de la famille.

 

Dans le code, la plupart des langages utilisent l’instruction suivante :

age = 24;

Le signe “=” est très souvent utilisé pour affecter une valeur à une variable. Attention que certains langages ont une instruction spécifique, comme le Pascal où le symbole utilisé est “:=”.

Le signe “=” est moins clair que le symbole du pseudo-code. En effet la flèche permet de savoir ce qu’il se passe. Même pour quelqu’un qui ne connaît pas le pseudo-code, il comprend bien que ce qui est à droite va dans ce qui est à gauche.

Pour le code, c’est à vous de vous rappeler de cela, l’affectation prend la valeur de droite pour la mettre à gauche ! Ceci dit, cela vient vite.

 

Et en pratique ?

Bon, c’est bien beau, je vous dis que la programmation n’est pas possible sans variable, mais pour le moment ce n’est pas forcément si clair.

Je vous propose donc un petit exemple avec la lecture commentée de l’algorithme. Je vais vous le fournir en pseudo-code, je vous laisserais le coder dans votre langage.

 

Calculer l’âge moyen d’une famille de 4 personnes

Réfléchissez à l’algorithme vous permettant de calculer l’âge moyen d’une famille de 4 personnes. Faites une pause dans la lecture de cet article et tentez, là tout de suite, d’écrire cet algorithme.

Vous l’avez écrit ?
Très bien.
Ma proposition consiste à demander l’âge de chaque membre de la famille puis calculer l’âge moyen et enfin afficher le résultat.

DECLARATIONS
  Entier ageMere;
  Entier agePere;
  Entier ageEnfant1;
  Entier ageEnfant2;
  Reel ageMoyenFamille;

DEBUT
  Afficher(“Saisir l’âge de la mère”);
  ageMere <- LireLigne();
  Afficher(“Saisir l’âge du père”);
  agePere <- LireLigne();
  Afficher(“Saisir l’âge du premier enfant”);
  ageEnfant1 <- LireLigne();
  Afficher(“Saisir l’âge du second enfant”);
  ageEnfant2 <- LireLigne();

  ageMoyenFamille <- (ageMere + agePere + ageEnfant1 + ageEnfant2) / 4;

  Afficher("L’âge moyen de cette famille est ");
  Afficher(ageMoyenFamille);
FIN

 

Décryptage de cet algorithme

En premier nous créons toutes les variables nécessaires, ici 4 entiers et un réel. En effet nous devons stocker des nombres entiers pour les âges et un nombre réel pour le résultat du calcul. Il s’agit de la déclaration des variables. Ces lignes de déclaration sont souvent mises dans un bloc nommé DECLARATION.

Pour votre information, certains langages permettent de faire la déclaration au dernier moment, d’autres langages vous forcent à le faire en début d’algorithme. Adaptez-vous à votre langage, sachant que les seconds ne vous interdisent pas non plus de faire la déclaration en début.

L’avantage du pseudo-code c’est que vous pouvez choisir de le faire au début ou au fil de l’algo.

 

Ensuite nous demandons à afficher le message “Saisir l’âge de la mère” grâce à la fonction Afficher.

Le côté sympa du pseudo-code c’est que l’on peut utiliser toutes les fonctions dont on a besoin sans être obligé de les avoir sous la main ou de les créer. Ce ne sera pas le cas dans le vrai code Java / C++ / etc. Ici j’ai décidé que je bénéficiais des fonctions Afficher, qui permet d’afficher un message à l’utilisateur, et LireLigne, qui permet de lire une ligne de saisie par l’utilisateur (c’est à dire beaucoup de caractères suivis par un retour chariot).

Bien sûr, inventer des fonctions sans fournir de code ne fonctionne que dans la mesure où c’est logique et cohérent. Ici il serait complètement hors sujet d’imaginer avoir une fonction calculMoyenneAgeFamille() qui fasse tout le travail.

Nous récupérons la saisie faite au clavier avec la fonction LireLigne() et nous affectons son résultat dans la variable adéquate, en premier ageMere. Nous répétons les mêmes instructions pour les autres variables, agePere, ageEnfant1 et ageEnfant2.

Ensuite il nous suffit de faire le calcul de la moyenne : sommer tous les âges et diviser par le nombre d’âges, c’est-à-dire 4. Nous affectons le résultat de ce calcul à la variable ageMoyenFamille.

Comment faire tout ceci sans l’aide de ces boites avec étiquettes que sont les variables ? Ce n’est pas possible ! Ici vous ne pourriez pas conserver “en mémoire” les informations saisies par l’utilisateur afin d’en calculer la moyenne.

Vous pourriez me répondre qu’un algorithme plus complexe pourrait sommer les ages pour ensuite n’avoir qu’à faire la division et afficher le résultat. Oui, c’est vrai, cet algo fonctionne. Il a tout de même besoin d’une variable pour calculer la somme !

Ne cherchez pas, on ne peut rien faire sans variable.

 

Pourquoi la variable ageMoyenFamille est-elle de type Réel ?

Nous aurions pu garder le type entier pour la variable ageMoyenFamille. Seulement le résultat de la division d’un entier par un autre est rarement un nombre entier.

En effet, si vous divisez 4 par 2 ou 15 par 3, vous obtenez des entiers, 2 et 5 respectivement. Par contre, si vous diviser 5 par 2 ou 16 par 3, vous obtenez des nombres réels, 2,5 et 5,33333333… respectivement. Logiquement, en divisant par 4, vous avez 1 chance sur 4 d’obtenir un nombre entier. Pour les 3 autres cas, vous aurez un nombre décimal, c’est-à-dire un nombre avec une virgule.

Si vous mettez le type entier pour la variable ageMoyenFamille, vous allez perdre de l’information, vous ne conserverez que la partie entière et perdrez tous les chiffres après la virgule. En indiquant que la variable ageMoyenFamille est de type réel, c’est-à-dire que c’est un nombre avec virgule, vous allez conserver cette information et vous pourrez donc l’afficher à la fin du programme.

Ce n’est ici qu’une question de choix. Vous pouvez très bien vous satisfaire d’une moyenne tronquée. Encore faut-il en être conscient.

Exécution manuelle de l’algorithme

Pour bien comprendre le fonctionnement d’un algorithme, nous vous recommandons de l’exécuter à la main sur une feuille de papier. Pour cela, nous représentons chaque variable sous forme d’une petite boite étiquetée avec le nom de la variable. Nous modifions ensuite les valeurs de chacune de ces boites, au fur et à mesure de l’avancement de l’algorithme.

Voici par exemple l’état des variables après la première affectation dans la variable ageMere.

Bien sûr, vous faites le choix aléatoire, mais cohérent, d’une valeur pour la variable concernée, ici j’ai choisi 38.

 

Ensuite, nous devons exécuter l’instruction d’affectation dans la variable agePere. Voici l’état après cette ligne de code :

Nous avons choisi 41 pour l’âge du père.

 

Vous avez compris la technique. Il suffit de continuer à lire l’algorithme en exécutant précisément les instructions de chaque ligne, une à une. Voici le résultat final pour tout l’algorithme :

 

Il n’y a pas de forme spécifique attendue, le tout est de bien exécuter chaque ligne de l’algorithme pas à pas. Ainsi, une autre version, plus simples, pourrait être :

 

 

A vous de jouer !

Reprenez cet algorithme et coder le dans votre langage de prédilection. Si vous êtes curieux d’apprendre et n’avez pas encore choisi un langage, vous pouvez lire mon article comment choisir son premier langage ?

Si votre choix se porte sur Java ou VBA pour Excel, voici des tutoriels pour vous lancer rapidement : tutoriel Java et tutoriel VBA pour Excel.

 

Vous savez maintenant beaucoup de choses sur les variables en informatique.
Est-ce que cela correspond à ce que vous imaginiez ? Avez-vous des exemples plus clairs à proposer ? Partagez toutes vos idées dans les commentaires.

Si vous avez aimé cet article, partagez le autour de vous et sur les réseaux sociaux.

 

Sources

Types en Java : https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
Types en C# : https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/keywords/integral-types-table
Types en C++ : https://fr.cppreference.com/w/cpp/language/types
Types en Javascript, norme ECMA : https://developer.mozilla.org/fr/docs/Web/JavaScript/Structures_de_donn%C3%A9es
Types en PHP : http://php.net/manual/fr/language.types.php