La mémoire de l'ordinateur peut être vue comme un très grand espace découpé en cases. Pour s'y retrouver, les différentes cases de cet espace ont été numérotées, chaque case porte ainsi une adresse.
Lorsque l'on connaît l'adresse d'une case, on peut demander d'aller consulter le contenu de la case en question. On peut également bien entendu modifier le contenu de cette case.
Une variable dans le programme représente en quelque sorte une case de la mémoire. Toute variable porte un nom qui permet de l'identifier dans le programme, et possède une adresse qui désigne la case qui lui est associée. Pour regarder la valeur d'une variable, c'est-à-dire son contenu, il faut donc aller dans la mémoire jusqu'à la case désignée par l'adresse de cette variable, puis lire le contenu de cette case. De même pour modifier la valeur de la variable.
La quantité de mémoire réservée pour une variable, c'est-à-dire la taille de la case associée, ainsi que la façon de lire et d'écrire dans cette case, dépend du type de contenu que l'on s'attend à y trouver. En effet en pratique une case est formée d'un certain nombre de bits qui peuvent prendre les valeurs 0 et 1. Il faut donc que lorsque l'on accède à cette case on connaisse le nombre de bits (c-à-d la taille de la case) et que l'on sache interpréter correctement ce qui a été codé dans cette suite de 0 et de 1. Par exemple les nombres entiers positifs, les nombres avec virgule, les nombres négatifs, les chaînes de caractères, etc., sont tous représentés au final par des 0 et des 1, mais bien évidemment la façon de coder ces informations n'est pas la même.
Le type de contenu d'une variable, duquel dépend la façon de stocker la valeur de cette variable, est donc primordial. On l'appelle le type de la variable.
Avant d'utiliser une variable il faut la déclarer, c'est-à-dire préciser de quel type est cette variable. Cette déclaration permet à l'ordinateur de réserver une case dans la mémoire ayant les bonnes propriétés (la bonne taille) et d'en retenir l'adresse, désormais associée au nom de la variable.
Par exemple, si l'on souhaite utiliser une variable censée représenter un nombre entier, il faut tout d'abord lui donner un nom, disons x, ainsi que préciser son type. Le type le plus courant pour désigner un nombre entier est le type int. Une liste des types courants sera donnée plus tard. Dans le programme il faudra ainsi écrire:
int x;
avant la toute première utilisation de x afin que l'ordinateur sache ce que représente x. Dès ce moment-là, on peut accéder à l'adresse de x grâce à l'opérateur ``prendre l'adresse de'' nommé &. L'adresse de x est ainsi &x.
Connaissant l'adresse a d'une variable, par exemple a = &x, on peut accéder à son contenu grâce à l'opérateur ``prendre le contenu de'' nommé *. Le contenu de la case numérotée a est ainsi *a, ou encore *&x.
Donnons un exemple simple. Soient x et y deux entiers, valant respectivement 4 et 5. On voudrait connaître leur somme et l'appeler z. La déclaration et l'instruction suivantes:
int x;
x = 4;
permettent de créer un entier nommé x (c-à-d de réserver une case qui aura un contenu de type int, et d'associer au nom x le numéro de cette case) puis de lui affecter la valeur 4 (c-à-d de remplir la case numérotée &x avec un code représentant le nombre 4). De même:
int y;
y = 5;
Et enfin, grâce à l'opérateur + qui est en fait une fonction prenant deux arguments (un devant lui et l'autre derrière) qui retourne la somme des deux entiers en question:
int z;
z = x + y;
Cette dernière instruction procède de la façon suivante: lire le contenu de la variable x et celui de la variable y, créer temporairement un autre entier (nommons-le w) dans lequel on écrit la somme des deux contenus, puis recopier la valeur de w (c-à-d le contenu de la case numéro &w) dans la case numéro &z, et enfin effacer la variable w qui n'est plus d'aucune utilité (c-à-d libérer la case numéro &w, ce qui n'a pas d'influence sur la case numéro &z puisque ce sont deux cases distinctes).
L'ordinateur exécutera les instructions dans l'ordre que l'on les lui a fournies. Du point de vue du programmeur, déclarer x avant y ou inversement n'a pas d'importance, il faut juste bien penser à déclarer les variables avant des les utiliser. Le morceau de programme ci-dessus peut donc être réécrit:
int x;
int y;
int z;
x = 4;
y = 5;
z = x + y;
ou encore, indifféremment pour le même résultat:
int z;
int x;
int y;
y = 5;
x = 4;
z = x + y;
La syntaxe des instructions et du programme est l'objet du prochain chapitre. Pour l'instant on se concentre sur les variables et la mémoire.