Une variable, qu’est ce que c’est réellement ?

Une boite représentant une variable

Les variables sont un des éléments incontournables de la programmation. Pour faire simple, s’il n’y a pas de variable, il n’y a pas de programme. Mais au fait, c’est quoi réellement une variable ? Voyons voir au-delà de sa capacité à stocker des nombres et jetons un petit coup d’œil dans la mémoire !

Pour faire simple !

Rôle d’une variable

À quoi sert une variable ? En gros, une variable nous permet dans un programme de retenir quelque chose. Ce quelque chose peut être un chiffre ou bien une lettre. Il va stocker une donnée qu’on appelle une valeur. Bien entendu, un programme peut avoir une multitude de variables qui vont l’aider à effectuer toutes ses actions.

Pour cela, chaque variable possède un nom ce qui nous permet de les identifier. Ce nom s’appelle aussi une étiquette. Ça nous sert tous simplement à les utiliser dans un programme.

Les variables permettent de retenir des données, mais cela reste temporaire. À la fin du programme, toutes les variables sont automatiquement détruites, elles ne peuvent donc pas être utilisées pour de la sauvegarde de données comme une base de données ou un fichier.

Il va y avoir dans une variable, comme son nom l’indique, une variation de la valeur au court du programme à la différence de son cousin, la constante. La valeur peut changer, un chiffre va passer par exemple de 12 à 95 ou une lettre de « p » à « f ». Ce qu’il faut retenir c’est que la valeur est susceptible de changer à tout moment dans le programme.

Opérations sur une variable

On peut faire plusieurs opérations avec une variable, son rôle ne se limite pas qu’à stocker une valeur.

Pour commencer, il y a la création d’une variable. Le logiciel ne peut pas deviner que vous voulez utiliser une variable. Il faut donc indiquer dans le programme que vous voulez créer une variable.

Pour pouvoir en créer une, il faut écrire le type de variable que vous souhaitez (nous allons y venir juste après), suivi de son nom et éventuellement une valeur. Cette opération s’appelle la déclaration d’une variable.

En C :

int maVariable;

En PHP :

$maVariable;

La déclaration d’une variable peut être différente suivant le langage que vous utilisez, mais on retrouve les grands principes à savoir le nom, la valeur et quelquefois le type.

Pour info, en PHP le typage des variables est géré automatiquement, c’est pour ça qu’on n’en met pas. En fonction de la valeur, le programme en PHP détermine le type à appliquer sur la variable.

L’opération qui permet de mettre une valeur à une variable s’appelle une affectation. Et la première affectation d’une variable s’appelle l’initialisation. Il est vivement recommandé d’initialiser une variable le plus vite possible. Sa valeur lors de sa création est aléatoire et pourrait provoquer des bugs si elle est utilisée.

Affectation en C :

maVariable = 12;

En PHP :

$maVariable = 12;

Notez bien que lorsqu’on utilise une variable, on ne spécifie pas le type de la variable, ce qui permet de différencier la déclaration avec les autres opérations.

Il est possible d’initialiser une variable en même temps que la déclaration :

Composition d'une déclaration de variable

Ensuite, nous pouvons faire des opérations mathématiques entre les variables, des opérations logiques, etc. Un article sur tous les types d’opérations possible sera dédié pour ça.

Typage et signature

Une variable peut contenir différents types de valeurs. Lors de la déclaration d’une variable, le fait d’indiquer le type d’une variable va lui faire stocker un type de données bien spécifique. Nous avons plusieurs grandes catégories de type :

  • Les nombres entiers
  • Les chiffres flottants, qui sont des nombres à virgules
  • Les alphanumériques, lettres et chiffres
  • Les booléens, VRAI ou FAUX, utilisés pour les comparaisons et les tests

Et c’est tout ! Avec ça, on peut déjà faire pas mal de trucs ! Attention quand même, une fois déclarée, une variable ne peut pas changer de type. De plus, il ne peut contenir qu’une valeur du type qu’il utilise. Une variable de type « nombre entier » ne pourra pas par exemple retenir une lettre.

Il y a dans ces catégories plusieurs autres types, mais elles traitent toutes le même type de données. La seule différence se joue sur la taille maximum que peut prendre une valeur dans une variable. Une variable de type « nombre entier » se décline en 4 types pour le langage C, chacun ayant une taille différente en mémoire.

Tous ces types sont appelés des types primitifs. Ce sont des valeurs très simples, primitives quoi.

Enfin, une variable peut être signée ou non. Chaque type de valeur peut avoir un nombre négatif, on dit qu’ils ont un signe. Pas besoin de spécifier quelque chose pour signer une variable, elles le sont par défaut. Par contre si vous ne voulez pas de chiffre négatif, vous devez indiquer que la variable n’est pas signée.

Exemple d’une variable non signé :

unsigned int maVariable = 12;

La signature d’une variable peut être considérée comme une autre catégorie de type.

Dans le typage, on retrouve donc les grandes catégories de type, suivi de la taille maximum que peut prendre une valeur dans une variable et enfin une signature indiquant si elle peut prendre une valeur négative.

Portée d’une variable

Il y a différente variante de variable, tout d’abord nous avons les variables classiques dites locales. Ce sont des variables qui n’existent que dans le bloc de code où elles sont créées. Une fois déclarée dans une fonction ou dans le main, elle existe jusqu’à ce que le programme atteint l’instruction return. Une fois le programme sorti de cette fonction, la variable est détruite et il n’est donc plus possible de l’utiliser.

Cette fonctionnalité va donc empêcher automatiquement d’autres fonctions d’accéder à une variable qui n’a pas été déclarée chez elles. On parle de portée d’une variable pour ce cas-ci.

Nous avons aussi les variables globales, elles sont créées au début du programme et meurent à la fin de celui-ci. Chaque bloc d’instructions peut accéder à cette variable. Elle a une portée globale d’où son nom. Pour créer une variable globale, c’est simple, il faut la déclarer en dehors de toute fonction. Une variable globale est assez pratique, mais elle présente quand même pas mal de soucis que j’explique ici.

Il existe enfin des variables dites statiques. Une variable déclarée en tant que statique restera en vie à la fin d’une fonction et conservera sa valeur. Pour créer une variable statique en C, il faut mettre le mot-clé static avant le type. Une variable globale est techniquement une variable statique.

Un peu de technique !

OK ! La version simple était en haut. Maintenant, voyons voir ce qui se passe réellement dans la mémoire.

Une RAM et une loupe

Création d’une variable en mémoire

Lors de la déclaration d’une variable, le programme va réserver une petite portion de la mémoire en fonction du type qui est utilisé.

La variable est créée dans une zone mémoire qui s’appelle la pile (stack en anglais). Je reste bref dans les détails, chaque programme exécuté est chargé dans la mémoire virtuelle de votre ordinateur. Cette mémoire virtuelle se situe en quelque sorte dans vos barrettes de RAM qui sont installées sur votre pc.

La mémoire virtuelle fait office de mémoire intermédiaire entre le disque dur qui est une mémoire de grande capacité, mais avec des temps d’accès lents et le processeur. La mémoire virtuelle offre un bon compromis entre vitesse et capacité. Dans cette mémoire, le programme chargé est divisé en plusieurs sections qui ont toutes un rôle bien particulier.

Une de ces sections est cette fameuse pile ! Cette zone de la mémoire à la particularité d’être géré automatiquement par le programme. Le programme calcule l’espace nécessaire à réserver dans cette mémoire, grâce au typage de la variable, et la détruit quand le programme ne s’en sert plus.

À quel moment elle ne s’en sert plus ? Très simple, quand le programme sort d’une fonction, les variables déclarées à l’intérieur sont automatiquement détruites. C’est ce qui fait notamment le principe de la portée.

La pile est gérée automatiquement par le programme ce qui est son gros point fort, mais elle présente un inconvénient de taille ! Elle est petite ! Du coup le programme est obligé de détruire les variables quand elles ne sont plus utilisées.

Une variable est en fait finalement qu’une petite zone de mémoire dont on lui a attribué un nom.

Taille d’une variable en mémoire

Suivant le type de la variable, le programme va réserver une certaine place dans la mémoire, je vais parler de cases mémoire pour simplifier le concept. La mémoire est composée d’octets, une RAM qui possède 100 octets possèdera donc 100 cases mémoire. Une case mémoire (octet) peut avoir une valeur comprise entre 0 et 255, donc 256 valeurs possibles.

Il faut savoir que peu importe le type de la valeur, ça sera toujours un chiffre qui sera dans la mémoire. Mais en fonction du type qui est précisé lors de la déclaration, le programme va les traiter de façon différente. La valeur en mémoire n’est donc pas exactement identique à la valeur d’une variable perçue par le programme.

De plus, le typage d’une variable va indiquer combien de cases mémoire le programme réservera pour une variable. Un chiffre entier va prendre en général entre 1 et 4 cases suivant le langage et le type utilisé.

Pour le langage C, voici une petite liste des types et de la place qu’ils prennent :

  • byte / char / bool : 1 case
  • short : 2 cases
  • int / float : 4 cases
  • long / double : 8 cases

Ça veut dire qu’un short peut avoir 512 valeurs possibles avec ses deux cases ? Eh non, en fait c’est multiplicatif. Quand le programme réserve un certain nombre de cases, les possibilités se multiple entre eux autant de fois qu’il y a de cases. En gros pour un short le calcul n’est pas 256 + 256, mais 256 * 256 ce qui donne 65 536 valeurs possibles !

  • byte / char / bool : 256 valeurs
  • short : 65 536 valeurs
  • int / float : 4 294 967 296 valeurs
  • long / double : 18 446 744 073 709 551 616 valeurs (pas besoin de le retenir celui-là)

OK, nous avons vu que des variables peuvent prendre une certaine taille et que cela influe sur la valeur qu’ils peuvent contenir. Mais comment stocker des lettres, des chiffres à virgule ou des nombres négatifs en mémoire alors que la valeur ne peut être qu’un chiffre entre 0 et 255 ?

Interprétation d’une variable en mémoire

Et bien c’est là que le rôle du type intervient ! Suivant le type de la variable, la valeur en mémoire sera traitée différemment dans le programme. Pour le cas d’un nombre non signé (pas de chiffre négatif), aucun traitement nécessaire ! La valeur de la variable est identique à la valeur stockée en mémoire.

Pour les nombres signés, c’est différent, le programme va diviser par deux le nombre de valeurs que peut prendre une variable. La première moitié sera considéré comme un chiffre positif, et la deuxième moitié comme un chiffre négatif.

Par exemple, pour le cas d’un byte avec 256 valeurs possible, s’il est signé, alors une valeur en mémoire de 0 à 127 sera perçue de la même manière dans le programme. Par contre, de 128 à 255 en mémoire, le programme comprendra -128 à -1.

  • unsigned byte / char / bool : 256 valeurs => 0 à 255
  • unsigned short : 65 536 valeurs => 0 à 65 535
  • byte / char / bool : 256 valeurs => -128 à 127
  • short : => 65 536 valeurs => -32 768 à 32 767

Pour les lettres, une valeur de 77 en mémoire va représenter la lettre « M’. Le programme se sert du tableau ASCII pour faire la transition entre la valeur en mémoire et la valeur en tant que type de caractère.

Enfin pour les nombres flottants, le programme va faire tout un calcul avec un exposant. Je parlerai du cas des nombres flottants dans un autre article ^^.

Comment ça marche pour les variables globales et statiques ? Et bien, ces variables-là sont spéciales et ne sont pas créées dans la pile, mais dans une autre section de la mémoire.

Comme elles existent à la création du programme et restent toujours en vie, le programme n’a pas besoin de les détruire, ni même de prévoir une possible réservation dans la mémoire. Du coup, elles sont mises dans une autre section de la mémoire, plus rapide en accès et qui n’est jamais détruite.

Bon avec ça, les variables n’ont plus trop de secrets pour vous :).

Partager l’article :
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.