Les variables

Pour comprendre ce qu’est une variable et comment manipuler celles-ci, il faut commencer par comprendre comment notre ordinateur fait pour stocker des données. En théorie, un ordinateur est capable de stocker tout type d’information. Mais comment est-il possible de réaliser un tel miracle alors qu’il ne s’agit finalement que d’un amas de circuits électriques ?

Codage des informations

Peut-être avez-vous déjà entendu le proverbe suivant : « si le seul outil que vous avez est un marteau, vous verrez tout problème comme un clou » (Abraham Maslow). Hé bien, l’idée est un peu la même pour un ordinateur : ce dernier ne sachant utiliser que des nombres, il voit toute information comme une suite de nombres.

L’astuce consiste donc à transformer une information en nombre pour que l’ordinateur puisse la traiter, autrement dit la numériser. Différentes techniques sont possibles pour atteindre cet objectif, une des plus simples étant une table de correspondance, par exemple entre un nombre et un caractère.

Binaire

Cependant, comme si cela ne suffisait pas, un ordinateur ne compte pas comme nous : il compte en base deux (l’andouille !).

La base correspond au nombre de chiffres disponibles pour représenter un nombre. En base 10, nous disposons de dix chiffres : zéro, un, deux, trois, quatre, cinq, six, sept, huit et neuf. En base deux, nous en avons donc… deux : zéro et un. Pour ce qui est de compter, c’est du pareil au même : nous commençons par épuiser les unités : 0, 1 ; puis nous passons aux dizaines : 10, 11 ; puis aux centaines : 100, 101, 110, 111 ; et ainsi de suite. Ci-dessous un petit tableau de correspondance entre la base deux et la base dix.

Un chiffre binaire (un zéro ou un un) est appelé un bit en anglais. Il s’agit de la contraction de l’expression « binary digit ». Nous l’emploierons assez souvent dans la suite de ce cours par souci d’économie.

Parce que les données circulent sous forme de courants électriques. Or, la tension de ceux-ci n’étant pas toujours stable, il est difficile de réaliser un système fiable sachant détecter dix valeurs différentes. Par contre, c’est parfaitement possible avec deux valeurs : il y a du courant ou il n’y en a pas.

La mémoire

Nous savons à présent que notre ordinateur ne sait employer que des nombres représentés en base deux.

Hé bien, les bits sont stockés dans un composant électronique particulier de l’ordinateur : la mémoire. Enfin, nous disons « la mémoire », mais il y en a en fait plusieurs.

Le fait est qu’il est actuellement impossible de créer des mémoires qui soient à la fois rapides et capables de contenir beaucoup de données. Nous ne pouvons donc utiliser une seule grosse mémoire capable de stocker toutes les données dont nous avons besoin. Ce problème s’est posé dès les débuts de l’informatique, comme en témoigne cette citation des années 1940, provenant des concepteurs d’un des tout premiers ordinateurs.

Mais les chercheurs et ingénieurs du début de l’informatique ont trouvé une solution : segmenter la mémoire de l’ordinateur en plusieurs sous-mémoires, de tailles et de vitesses différentes, utilisées chacune suivant les besoins. Nous aurons donc des mémoires pouvant contenir peu de données et rapides, à côté de mémoires plus importantes et plus lentes.

Nous vous avons dit que l’ordinateur utilisait plusieurs mémoires. Trois d’entre elles méritent à notre sens votre attention :

• les registres ;
• la mémoire vive (ou RAM en anglais) ;
• le disque dur.

Les registres sont des mémoires intégrées dans le processeur, utilisées pour stocker des données temporaires. Elles sont très rapides, mais ne peuvent contenir que des données très simples, comme des nombres.

La mémoire vive est une mémoire un peu plus grosse, mais plus lente que les registres. Elle peut contenir pas mal de données et est généralement utilisée pour stocker les programmes en cours d’exécution ainsi que les données qu’ils manipulent.

Ces deux mémoires (les registres et la mémoire vive) ont tout de même un léger défaut : elles perdent leur contenu quand elles ne sont plus alimentées… Autant dire que ce n’est pas le meilleur endroit pour stocker un système d’exploitation ou des fichiers personnels. Ceci est le rôle du disque dur, une mémoire avec une capacité très importante, mais très lente qui a toutefois l’avantage d’assurer la persistance des données.

En C, la mémoire la plus manipulée par le programmeur est la mémoire vive. Aussi, nous allons nous y intéresser d’un peu plus près dans ce qui suit.

Bits, multiplets et octets

Dans la mémoire vive, les bits sont regroupés en « paquets » de quantité fixe : des « cases mémoires », aussi appelées multiplets (ou bytes en anglais). À quelques exceptions près, les mémoires utilisent des multiplets de huit bits, aussi appelés octets. Un octet peut stocker 256 informations différentes (vous pouvez faire le calcul vous-même : combien vaut 11111111 en base deux ? ). Pour stocker plus d’informations, il sera nécessaire d’utiliser plusieurs octets.

Adresse mémoire

Néanmoins, il est bien beau de stocker des données en mémoire, encore faut-il pouvoir remettre la main dessus.

Dans cette optique, chaque multiplet de la mémoire vive se voit attribuer un nombre unique, une adresse, qui va permettre de le sélectionner et de l’identifier parmi tous les autres. Imaginez la mémoire vive de l’ordinateur comme une immense armoire, qui contiendrait beaucoup de tiroirs (les cases mémoires) pouvant chacun contenir un multiplet. Chaque tiroir se voit attribuer un numéro pour le reconnaitre parmi tous les autres. Nous pourrions ainsi demander quel est le contenu du tiroir numéro 27. Pour la mémoire, c’est pareil. Chaque case mémoire a un numéro : son adresse.

En fait, vous pouvez comparer une adresse à un numéro de téléphone : chacun de vos correspondants a un numéro de téléphone et vous savez que pour appeler telle personne, vous devez composer tel numéro. Les adresses mémoires fonctionnent exactement de la même façon !

Les variables

Tout cela est bien sympathique, mais manipuler explicitement des références (des adresses si vous préférez) est un vrai calvaire, de même que de s’évertuer à calculer en base deux. Heureusement pour nous, les langages de programmation (et notamment le C), se chargent d’effectuer les conversions pour nous et remplacent les références par des variables.

Une variable correspondra à une portion de mémoire, appelée objet, à laquelle nous donnerons un nom. Ce nom permettra d’identifier notre variable, tout comme une référence permet d’identifier une portion de mémoire parmi toutes les autres. Nous allons ainsi pouvoir nommer les données que nous manipulons, chacun de ces noms étant remplacé lors de la compilation par une référence (le plus souvent une adresse).

Entrons maintenant dans le vif du sujet en apprenant à déclarer nos variables. Tout d’abord, sachez qu’une variable est constituée de deux éléments obligatoires :

• un type ;
• un identificateur qui est en gros le « nom » de la variable.

Le type d’une variable permet d’indiquer ce qui y sera stocké, par exemple : un caractère, un nombre entier, un nombre réel (ou nombre à virgule flottante, parfois tout simplement abrégé en « flottant »), etc. Pour préciser le type d’une variable, il est nécessaire d’utiliser un mot-clé spécifique (il y en a donc un pour chaque type).

Une fois que nous avons décidé du nom et du type de notre variable, nous pouvons la créer (on dit aussi la déclarer) comme suit.

type identificateur;

En clair, il suffit de placer un mot-clé indiquant le type de la variable et de placer le nom qu’on lui a choisi immédiatement après.

Les types

Comme dit précédemment, un type permet d’indiquer au compilateur quel genre de données nous souhaitons stocker. Ce type va permettre de préciser :

• toutes les valeurs que peut prendre la variable ;
• les opérations qu’il est possible d’effectuer avec (il n’est par exemple pas possible de réaliser une division entière avec un nombre à virgule flottante, nous y reviendrons).

Définir le type d’une variable permet donc de préciser son contenu potentiel et ce que nous pouvons faire avec. Le langage C fournit dix types de base.

Le type char sert au stockage de caractères.

Les types signed char, short int, int, long int et long long int servent tous à stocker des nombres entiers qui peuvent prendre des valeurs positives, négatives, ou nulles. On dit qu’il s’agit de types signés, car ils peuvent comporter un signe. Pour chacun de ces cinq types, il existe un type équivalent dit non signé. Un type entier non signé est un type entier qui n’accepte que des valeurs positives ou nulles : il ne peut pas stocker de valeurs négatives. Pour déclarer des variables d’un type non signé, il vous suffit de faire précéder le nom du type entier du mot-clé unsigned.

Le type _Bool³ est un type entier non signé un peu particulier : il permet de stocker soit 0, soit 1, on parle d’un booléen (nous verrons de quoi il s’agit un peu plus tard). À ce titre, _Bool est le type entier non signé avec la plus faible capacité.

Les types float, double et long double permettent quant à eux de stocker des nombres réels.⁴

Capacité d’un type

Les types entiers et flottants

Tous les types stockant des nombres ont des bornes, c’est-à-dire une limite aux valeurs qu’ils peuvent stocker. En effet, le nombre de multiplets occupés par une variable est limité suivant son type. En conséquence, il n’est pas possible de mettre tous les nombres possibles dans une variable de type int, float, ou double. Il y aura toujours une valeur minimale et une valeur maximale. Ces limites sont les suivantes.

Si vous regardez bien ce tableau, vous remarquez que certains types ont des bornes identiques. En vérité, les valeurs présentées ci-dessus sont les minimums garantis par la norme¹ et il est fort probable qu’en réalité, vous puissiez stocker des valeurs plus élevées que ceux-ci. Cependant, dans une optique de portabilité, vous devez considérer ces valeurs comme les minimums et les maximums de ces types, peu importe la capacité réelle de ces derniers sur votre machine.

Le type char

Le type char quant à lui est garanti de pouvoir stocker un ensemble de caractères limités. il s’agit des caractères suivants.

A B C D E F G H I J K L M
N O P Q R S T U V W X Y Z
a b c d e f g h i j k l m
n o p q r s t u v w x y z
0 1 2 3 4 5 6 7 8 9
! " # % & ' ( ) * + , - . / :
; < = > ? [ \ ] ^ _ { | } ~

Auxquels s’ajoutent l’espace, la tabulation, le retour à la ligne et quelques caractères spéciaux (nous en parlerons davantage plus tard dans ce cours). À nouveau il s’agit du minimum garantit par la norme.

Taille d’un type

Peut-être vous êtes vous demandé pourquoi il existe autant de types différents. La réponse est toute simple : la taille des mémoires était très limitée à l’époque où le langage C a été créé. En effet, le PDP-11 sur lequel le C a été conçu ne possédait que 24Ko de mémoire (pour comparaison, une calculatrice TI-Nspire possède 100Mo de mémoire, soit environ 4000 fois plus). Il fallait donc l’économiser au maximum en choisissant le type le plus petit possible. Cette taille dépend des machines, mais de manière générale, vous pouvez retenir les deux suites d’inégalités suivantes : signed char ≤ short ≤ int ≤ long ≤ long long et float ≤ double ≤ long double.

Aujourd’hui ce n’est plus un problème, il n’est pas nécessaire de se casser la tête sur quel type choisir (excepté si vous voulez programmer pour de petits appareils où la mémoire est plus petite). En pratique, nous utiliserons surtout char pour les caractères, int, long ou long long pour les entiers et double pour les réels.

Les identificateurs

Maintenant que nous avons vu les types, parlons des identificateurs. Comme dit précédemment, un identificateur est un nom donné à une variable pour la différencier de toutes les autres. Et ce nom, c’est au programmeur de le choisir. Cependant, il y a quelques limitations à ce choix.

• seuls les 26 lettres de l’alphabet latin (majuscules ou minuscules), le trait de soulignement « _ » (underscore en anglais) et les chiffres sont acceptés. Pas d’accents, pas de ponctuation ni d’espaces ;
• un identificateur ne peut pas commencer par un chiffre ;
• les mots-clés ne peuvent pas servir à identifier une variable ; il s’agit de :

auto         if        unsigned
break        inline    void
case         int       volatile
char         long      while
const        register  _Alignas
continue     restrict  _Alignof
default      return    _Atomic
do           short     _Bool
double       signed    _Complex
else         sizeof    _Generic
enum         static    _Imaginary
extern       struct    _Noreturn
float        switch    _Static_assert
for          typedef   _Thread_local
goto         union

• deux variables ne peuvent avoir le même identificateur (le même nom). Il y a parfois quelques exceptions, mais cela n’est pas pour tout de suite ;
• les identificateurs peuvent être aussi longs que l’on désire, toutefois le compilateur ne tiendra compte que des 63 premiers caractères².

Voici quelques exemples pour bien comprendre.

À noter que le C fait la différence entre les majuscules et les minuscules (on dit qu’il respecte la casse). Ainsi les trois identificateurs suivants sont différents.

variable
Variable
VaRiAbLe

Déclaration

Maintenant que nous connaissons toutes les bases, entrainons-nous à déclarer quelques variables.

int main(void)
{
    _Bool booleen;
    double taille;
    unsigned int age;
    char caractere;
    short petite_valeur;

    return 0;
}

Il est possible de déclarer plusieurs variables de même type sur une même ligne, en séparant leur noms par une virgule.

int age, taille, nombre;

Ceci permet de regrouper les déclarations suivant les rapports que les variables ont entre elles.

int annee, mois, jour;
int age, taille;
int x, y, z;

En plus de déclarer une variable, il est possible de l’initialiser, c’est-à-dire de lui attribuer une valeur. La syntaxe est la suivante.

type identificateur = valeur;

Initialisation des types entiers

Pour les types entiers, c’est assez simple, la valeur à attribuer est… un nombre entier.

_Bool booleen = 0;
unsigned char age = 42;
long score = -1;

Initialisation des types réels

Pour les types réels, ceux-ci étant faits pour contenir des nombres à virgule, à l’initialisation, il est nécessaire de placer cette « virgule ». Toutefois, cette dernière est représentée par un point.

double pi = 3.14;

Ceci vient du fait que le C est une invention américaine et que les anglophones utilisent le point à la place de la virgule.

En notation scientifique

Par ailleurs, il est également possible de représenter un nombre à virgule flottante à l’aide de la notation scientifique, c’est-à-dire sous la forme d’un nombre décimal et d’une puissance de dix. Cela se traduit par un nombre réel en notation simple (comme ci-dessus) suivi de la lettre « e » ou « E » et d’un exposant entier.

double f = 1E-1; /* 1x10^-1 = 0.1 */

Initialisation du type char

Nous l’avons précisé : le type char peut être utilisé pour contenir un entier ou un caractère. Dans le second cas, le caractère utilisé pour l’initialisation doit être entouré de guillemets simples, comme suit.

char a = 'a';

Rendre une variable constante

En plus d’attribuer une valeur à une variable, il est possible de préciser que cette variable ne pourra pas être modifiée par la suite à l’aide du mot-clé const. Ceci peut être utile pour stocker une valeur qui ne changera jamais (comme la constante $\pi$ qui vaut toujours 3,14159265).

const double pi = 3.14159265;

Nous savons donc déclarer (créer) nos variables et les initialiser (leur donner une valeur à la création). Il ne nous reste plus qu’à voir la dernière manipulation possible : l’affectation. Celle-ci permet de modifier la valeur contenue dans une variable pour la remplacer par une autre valeur.

Il va de soi que cette affectation n’est possible que pour les variables qui ne sont pas déclarées avec le mot-clé const puisque, par définition, de telles variables sont constantes et ne peuvent voir leur contenu modifié.

Pour faire une affectation, il suffit d’opérer ainsi.

identificateur = nouvelle_valeur;

Nous voyons que la syntaxe est similaire à celle d’une déclaration avec initialisation. La seule différence, c’est que nous n’avons pas à préciser le type. Celui-ci est en effet fixé une fois pour toute lors de la déclaration de notre variable. Aussi, il n’est pas nécessaire de le préciser à nouveau lors d’une affectation.

age = 30;
taille = 177.5;
petite_valeur = 2;

Notez qu’il n’y a aucune limite au nombre d’affectations, comme le démontre l’exemple ci-dessous.

petite_valeur = 2;
petite_valeur = 4;
petite_valeur = 8;
petite_valeur = 16;
petite_valeur = 8;
petite_valeur = 4;
petite_valeur = 2;

À chaque affectation, la variable va prendre une nouvelle valeur. Par contre, ne mettez pas le type quand vous voulez changer la valeur, sinon vous aurez le droit à une belle erreur du type « redefinition of 'nom_de_votre_variable' » car vous aurez créé deux variables avec le même identificateur !

Le code suivant est donc incorrect.

int age = 15;
int age = 20;

Si vous exécutez tous ces codes, vous verrez qu’ils n’affichent toujours rien et c’est normal puisque nous n’avons pas demandé à notre ordinateur d’afficher quoi que ce soit. Nous apprendrons comment faire au chapitre suivant.

Pour terminer ce chapitre, nous vous proposons un petit aparté sur deux représentations particulières : la représentation octale et la représentation hexadécimale.

Nous avons déjà vu la représentation binaire au début de ce chapitre, les représentations octale et hexadécimale obéissent au même schéma : au lieu d’utiliser dix chiffres pour représenter un nombre, nous en utilisons respectivement huit ou seize.

La représentation hexadécimale est un peu déroutante de prime abord, celle-ci ajoute six chiffres (en fait, six lettres) : a, b, c, d, e et f. Pour vous aider, voici un tableau présentant les nombres de 0 à 16 en binaire, octal, décimal et hexadécimal.

L’avantage des représentations octale et hexadécimale est qu’il est facilement possible de les convertir en binaire contrairement à la représentation décimale. En effet, un chiffre en base huit ou en base seize peut être facilement traduit, respectivement, en trois ou quatre bits.

Prenons l’exemple du nombre 35 qui donne 43 en octal et 23 en hexadécimal. Nous pouvons nous focaliser sur chaque chiffre un à un pour obtenir la représentation binaire. Ainsi, du côté de la représentation octale, 4 donne 100 et 3 011, ce qui nous donne finalement 00100011. De même, pour la représentation hexadécimale, 2 nous donne 0010 et 3 0011 et nous obtenons 00100011. Il n’est pas possible de faire pareil en décimal.

En résumé, les représentations octale et hexadécimale permettent de représenter un nombre binaire de manière plus concise et plus lisible.

Constantes octales et hexadécimales

Il vous est possible de préciser la base d’une constante entière en utilisant des préfixes. Ces préfixes sont 0 pour les constantes octales et 0x ou 0X pour les constantes hexadécimales.

long a = 65535; /* En décimal */
int b = 0777; /* En octal */
short c = 0xFF; /* En hexadécimal */

Malheureusement, non, le langage C ne permet pas d’utiliser de telles constantes.