Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Ce cours existe en eBook.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !
Apprenez à programmer en C !

Apprenez à programmer en C !

Mis à jour le lundi 11 août 2014
  • 4 semaines
  • Moyen

Vous savez afficher un texte à l'écran. Très bien. Ça ne vole peut-être pas très haut pour le moment, mais c'est justement parce que vous ne connaissez pas encore ce qu'on appelle les variables en programmation.

Le principe dans les grandes lignes, c'est de faire retenir des nombres à l'ordinateur. On va apprendre à stocker des nombres dans la mémoire.

Je souhaite que nous commencions par quelques explications sur la mémoire de votre ordinateur. Comment fonctionne une mémoire ? Combien un ordinateur possède-t-il de mémoires différentes ? Cela pourra paraître un peu simpliste à certains d'entre vous, mais je pense aussi à ceux qui ne savent pas bien ce qu'est une mémoire.

Une affaire de mémoire

Ce que je vais vous apprendre dans ce chapitre a un rapport direct avec la mémoire de votre ordinateur.

Tout être humain normalement constitué a une mémoire. Eh bien c'est pareil pour un ordinateur… à un détail près : un ordinateur a plusieurs types de mémoire !

Pourquoi un ordinateur aurait-il plusieurs types de mémoire ? Une seule mémoire aurait suffi, non ?

Non : en fait, le problème c'est qu'on a besoin d'avoir une mémoire à la fois rapide (pour récupérer une information très vite) et importante (pour stocker beaucoup de données). Or, vous allez rire, mais jusqu'ici nous avons été incapables de créer une mémoire qui soit à la fois très rapide et importante. Plus exactement, la mémoire rapide coûte cher, on n'en fait donc qu'en petites quantités.

Du coup, pour nous arranger, nous avons dû doter les ordinateurs de mémoires très rapides mais pas importantes, et de mémoires importantes mais pas très rapides (vous suivez toujours ?).

Les différents types de mémoire

Pour vous donner une idée, voici les différents types de mémoire existant dans un ordinateur, de la plus rapide à la plus lente :

  1. les registres : une mémoire ultra-rapide située directement dans le processeur ;

  2. la mémoire cache : elle fait le lien entre les registres et la mémoire vive ;

  3. la mémoire vive : c'est la mémoire avec laquelle nous allons travailler le plus souvent ;

  4. le disque dur : que vous connaissez sûrement, c'est là qu'on enregistre les fichiers.

Comme je vous l'ai dit, j'ai classé les mémoires de la plus rapide (les registres) à la plus lente (le disque dur). Si vous avez bien suivi, vous avez compris aussi que la mémoire la plus rapide était la plus petite, et la plus lente la plus grosse.
Les registres sont donc à peine capables de retenir quelques nombres, tandis que le disque dur peut stocker de très gros fichiers.

Que faut-il retenir dans tout ça ?
En fait, je souhaite vous situer un peu. Vous savez désormais qu'en programmation, on va surtout travailler avec la mémoire vive. On verra aussi comment lire et écrire sur le disque dur, pour lire et créer des fichiers (mais on ne le fera que plus tard). Quant à la mémoire cache et aux registres, on n'y touchera pas du tout ! C'est votre ordinateur qui s'en occupe.

Il faut ajouter une dernière chose très importante : seul le disque dur retient tout le temps les informations qu'il contient. Toutes les autres mémoires (registres, mémoire cache, mémoire vive) sont des mémoires temporaires : lorsque vous éteignez votre ordinateur, ces mémoires se vident !

Heureusement, lorsque vous rallumerez l'ordinateur, votre disque dur sera toujours là pour rappeler à votre ordinateur qui il est.

La mémoire vive en photos

Vu qu'on va travailler pendant un moment avec la mémoire vive, je pense qu'il serait bien de vous la présenter.

On va y aller par zooms successifs. Commençons par votre ordinateur (fig. suivante).

Un ordinateur et tous ses composants

Vous reconnaissez le clavier, la souris, l'écran et l'unité centrale (la tour). Intéressons-nous maintenant à l'unité centrale (fig. suivante), le cœur de votre ordinateur qui contient toutes les mémoires.

L'unité centrale

Ce qui nous intéresse, c'est ce qu'il y a à l'intérieur de l'unité centrale. Ouvrons-la (fig. suivante).

Intérieur de l'unité centrale

C'est un joyeux petit bazar. Rassurez-vous, je ne vous demanderai pas de savoir comment tout cela fonctionne. Je veux juste que vous sachiez où se trouve la mémoire vive là-dedans. Je vous l'ai encadrée. Je n'ai pas indiqué les autres mémoires (registres et mémoire cache) car de toute façon elles sont bien trop petites pour être visibles à l'œil nu.

Voici à quoi ressemble une barrette de mémoire vive de plus près (fig. suivante).

Une barrette de mémoire vive

La mémoire vive est aussi appelée RAM, ne vous étonnez donc pas si par la suite j'utilise plutôt le mot RAM qui est un peu plus court.

Le schéma de la mémoire vive

En photographiant de plus près la mémoire vive, on n'y verrait pas grand-chose. Pourtant, il est très important de savoir comment ça fonctionne à l'intérieur. C'est d'ailleurs là que je veux en venir depuis tout à l'heure.

Je vous propose un schéma du fonctionnement de la mémoire vive (fig. suivante). Il est très simplifié (comme mes schémas de compilation !), mais c'est parce que nous n'avons pas besoin de trop de détails. Si vous retenez ce schéma, ce sera déjà très bien !

Organisation de la mémoire vive

Comme vous le voyez, il faut en gros distinguer deux colonnes.

  • Il y a les adresses : une adresse est un nombre qui permet à l'ordinateur de se repérer dans la mémoire vive. On commence à l'adresse 0 (au tout début de la mémoire) et on finit à l'adresse 3 448 765 900 126 et des poussières… Euh, en fait je ne connais pas le nombre d'adresses qu'il y a dans la RAM, je sais juste qu'il y en a beaucoup.
    En plus ça dépend de la quantité de mémoire vive que vous avez. Plus vous avez de mémoire vive, plus il y a d'adresses, donc plus on peut stocker de choses.

  • À chaque adresse, on peut stocker une valeur (un nombre) : votre ordinateur stocke dans la mémoire vive ces nombres pour pouvoir s'en souvenir par la suite. On ne peut stocker qu'un nombre par adresse !

Notre RAM ne peut stocker que des nombres.

Mais alors, comment fait-on pour retenir des mots ?

Bonne question. En fait, même les lettres ne sont que des nombres pour l'ordinateur ! Une phrase est une simple succession de nombres.
Il existe un tableau qui fait la correspondance entre les nombres et les lettres. C'est un tableau qui dit par exemple : le nombre 67 correspond à la lettre Y. Je ne rentre pas dans les détails, on aura l'occasion de reparler de cela plus loin dans le cours.

Revenons à notre schéma. Les choses sont en fait très simples : si l'ordinateur veut retenir le nombre 5 (qui pourrait être le nombre de vies qu'il reste au personnage d'un jeu), il le met quelque part en mémoire où il y a de la place et note l'adresse correspondante (par exemple 3 062 199 902).
Plus tard, lorsqu'il veut savoir à nouveau quel est ce nombre, il va chercher à la « case » mémoire n° 3 062 199 902 ce qu'il y a, et il trouve la valeur… 5 !

Voilà en gros comment ça fonctionne. C'est peut-être un peu flou pour le moment (quel intérêt de stocker un nombre s'il faut à la place retenir l'adresse ?) mais tout va rapidement prendre du sens dans la suite de ce chapitre, je vous le promets.

Déclarer une variable

Croyez-moi, cette petite introduction sur la mémoire va nous être plus utile que vous ne le pensez.
Maintenant que vous savez ce qu'il faut, on peut retourner programmer.

Alors une variable, c'est quoi ?
Eh bien c'est une petite information temporaire qu'on stocke dans la RAM. Tout simplement.
On dit qu'elle est « variable » car c'est une valeur qui peut changer pendant le déroulement du programme. Par exemple, notre nombre 5 de tout à l'heure (le nombre de vies restant au joueur) risque de diminuer au fil du temps. Si ce nombre atteint 0, on saura que le joueur a perdu.

Nos programmes, vous allez le voir, sont remplis de variables. Vous allez en voir partout, à toutes les sauces.

En langage C, une variable est constituée de deux choses :

  • une valeur : c'est le nombre qu'elle stocke, par exemple 5 ;

  • un nom : c'est ce qui permet de la reconnaître. En programmant en C, on n'aura pas à retenir l'adresse mémoire (ouf !) : à la place, on va juste indiquer des noms de variables. C'est le compilateur qui fera la conversion entre le nom et l'adresse. Voilà déjà un souci de moins.

Donner un nom à ses variables

En langage C, chaque variable doit donc avoir un nom. Pour notre fameuse variable qui retient le nombre de vies, on aimerait bien l'appeler « Nombre de vies » ou quelque chose du genre.

Hélas, il y a quelques contraintes. Vous ne pouvez pas appeler une variable n'importe comment :

  • il ne peut y avoir que des minuscules, majuscules et des chiffres (abcABC012) ;

  • votre nom de variable doit commencer par une lettre ;

  • les espaces sont interdits. À la place, on peut utiliser le caractère « underscore » _ (qui ressemble à un trait de soulignement). C'est le seul caractère différent des lettres et chiffres autorisé ;

  • vous n'avez pas le droit d'utiliser des accents (éàê etc.).

Enfin, et c'est très important à savoir, le langage C fait la différence entre les majuscules et les minuscules. Pour votre culture, sachez qu'on dit que c'est un langage qui « respecte la casse ».
Donc, du coup, les variables largeur, LARGEUR ou encore LArgEuR sont trois variables différentes en langage C, même si pour nous ça a l'air de signifier la même chose !

Voici quelques exemples de noms de variables corrects : nombreDeVies, prenom, nom, numero_de_telephone, numeroDeTelephone.

Chaque programmeur a sa propre façon de nommer des variables. Pendant ce cours, je vais vous montrer ma manière de faire :

  • je commence tous mes noms de variables par une lettre minuscule ;

  • s'il y a plusieurs mots dans mon nom de variable, je mets une lettre majuscule au début de chaque nouveau mot.

Je vais vous demander de faire de la même manière que moi, ça nous permettra d'être sur la même longueur d'ondes.

Les types de variables

Notre ordinateur, vous pourrez le constater, n'est en fait rien d'autre qu'une (très grosse) machine à calculer. Il ne sait traiter que des nombres.

Oui mais voilà, j'ai un scoop ! Il existe plusieurs types de nombres ! Par exemple, il y a les nombres entiers positifs :

  • 45 ;

  • 398 ;

  • 7650.

Mais il y a aussi des nombres décimaux, c'est-à-dire des nombres à virgule :

  • 75,909 ;

  • 1,7741 ;

  • 9810,7.

En plus de ça, il y a aussi des nombres entiers négatifs :

  • -87 ;

  • -916.

… Et des nombres négatifs décimaux !

  • -76,9 ;

  • -100,11.

Votre pauvre ordinateur a besoin d'aide ! Lorsque vous lui demandez de stocker un nombre, vous devez dire de quel type il est. Ce n'est pas vraiment qu'il ne soit pas capable de le reconnaître tout seul, mais… ça l'aide beaucoup à s'organiser, et à faire en sorte de ne pas prendre trop de mémoire pour rien.

Lorsque vous créez une variable, vous allez donc devoir indiquer son type.
Voici les principaux types de variables existant en langage C :

Nom du type

Minimum

Maximum

signed char

-127

127

int

-32 767

32 767

long

-2 147 483 647

2 147 483 647

float

-1 x1037

1 x1037

double

-1 x1037

1 x1037

Les trois premiers types (signed char, int, long) permettent de stocker des nombres entiers : 1, 2, 3, 4…
Les deux derniers (float, double) permettent de stocker des nombres décimaux (appelés nombres flottants) : 13.8, 16.911…

Vous verrez que la plupart du temps on manipule des nombres entiers (tant mieux, parce que c'est plus facile à utiliser).

Ce n'est pas tout ! Pour les types entiers (signed char, int, long…), il existe d'autres types dits unsigned (non signés) qui eux ne peuvent stocker que des nombres positifs. Pour les utiliser, il suffit d'écrire le mot unsigned devant le type :

unsigned char

0 à 255

unsigned int

0 à 65 535

unsigned long

0 à 4 294 967 295

Comme vous le voyez, les unsigned sont des types qui ont le défaut de ne pas pouvoir stocker de nombres négatifs, mais l'avantage de pouvoir stocker des nombres deux fois plus grands (signed char s'arrête à 127, tandis que unsigned char s'arrête à 255 par exemple).

Pourquoi avoir créé trois types pour les nombres entiers ? Un seul type aurait été suffisant, non ?

Oui, mais on a créé à l'origine plusieurs types pour économiser de la mémoire. Ainsi, quand on dit à l'ordinateur qu'on a besoin d'une variable de type char, on prend moins d'espace en mémoire que si on avait demandé une variable de type int.

Toutefois, c'était utile surtout à l'époque où la mémoire était limitée. Aujourd'hui, nos ordinateurs ont largement assez de mémoire vive pour que ça ne soit plus vraiment un problème. Il ne sera donc pas utile de se prendre la tête pendant des heures sur le choix d'un type. Si vous ne savez pas si votre variable risque de prendre une grosse valeur, mettez int (ou double pour un flottant).

En résumé, on fera surtout la distinction entre nombres entiers et flottants :

  • pour un nombre entier, on utilisera le plus souvent int ;

  • pour un nombre flottant, on utilisera généralement double.

Déclarer une variable

On y arrive. Maintenant, créez un nouveau projet console que vous appellerez « variables ».
On va voir comment déclarer une variable, c'est-à-dire demander à l'ordinateur la permission d'utiliser un peu de mémoire.

Une déclaration de variable, c'est très simple maintenant que vous savez tout ce qu'il faut. Il suffit dans l'ordre :

  1. d'indiquer le type de la variable que l'on veut créer ;

  2. d'insérer un espace ;

  3. d'indiquer le nom que vous voulez donner à la variable ;

  4. et enfin, de ne pas oublier le point-virgule.

Par exemple, si je veux créer ma variable nombreDeVies de type int, je dois taper la ligne suivante :

int nombreDeVies;

Et c'est tout ! Quelques autres exemples stupides pour la forme :

int noteDeMaths;
double sommeArgentRecue; 
unsigned int nombreDeLecteursEnTrainDeLireUnNomDeVariableUnPeuLong;

Bon bref, vous avez compris le principe je pense !

Ce qu'on fait là s'appelle une déclaration de variable (un vocabulaire à retenir). Vous devez faire les déclarations de variables au début des fonctions. Comme pour le moment on n'a qu'une seule fonction (la fonction main), vous allez déclarer la variable comme ceci :

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[]) // Équivalent de int main()
{
  int nombreDeVies; 
     
  return 0;
}

Si vous lancez le programme ci-dessus, vous constaterez avec stupeur… qu'il ne fait rien.

Quelques explications

Alors, avant que vous ne m'étrangliez en croyant que je vous mène en bateau depuis tout à l'heure, laissez-moi juste dire une chose pour ma défense.

En fait, il se passe des choses, mais vous ne les voyez pas. Lorsque le programme arrive à la ligne de la déclaration de variable, il demande bien gentiment à l'ordinateur s'il peut utiliser un peu d'espace dans la mémoire vive.
Si tout va bien, l'ordinateur répond « Oui bien sûr, fais comme chez toi ». Généralement, cela se passe sans problème. Le seul souci qu'il pourrait y avoir, c'est qu'il n'y ait plus de place en mémoire… Mais heureusement cela arrive rarement, car pour remplir toute la mémoire rien qu'avec des int il faut vraiment le vouloir !

Soyez donc sans crainte, vos variables devraient normalement être créées sans souci.

Et maintenant ?
Maintenant qu'on a créé notre variable, on va pouvoir lui donner une valeur.

Affecter une valeur à une variable

C'est tout ce qu'il y a de plus bête. Si vous voulez donner une valeur à la variable nombreDeVies, il suffit de procéder comme ceci :

nombreDeVies = 5;

Rien de plus à faire. Vous indiquez le nom de la variable, un signe égal, puis la valeur que vous voulez y mettre.
Ici, on vient de donner la valeur 5 à la variable nombreDeVies.
Notre programme complet ressemble donc à ceci :

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[])
{
  int nombreDeVies;
  nombreDeVies = 5;
       
  return 0;
}

Là encore, rien ne s'affiche à l'écran, tout se passe dans la mémoire.
Quelque part dans les tréfonds de votre ordinateur, une petite case de mémoire vient de prendre la valeur 5. N'est-ce pas magnifique ?

On peut s'amuser si on veut à changer la valeur par la suite :

int nombreDeVies; 
nombreDeVies = 5;
nombreDeVies = 4;
nombreDeVies = 3;

Dans cet exemple, la variable va prendre d'abord la valeur 5, puis 4, et enfin 3. Comme votre ordinateur est très rapide, tout cela se passe extrêmement vite. Vous n'avez pas le temps de cligner des yeux que votre variable vient de prendre les valeurs 5, 4 et 3… et ça y est, votre programme est fini.

La valeur d'une nouvelle variable

Voici une question très importante que je veux vous soumettre :

Quand on déclare une variable, quelle valeur a-t-elle au départ ?

En effet, quand l'ordinateur lit cette ligne :

int nombreDeVies;

il réserve un petit emplacement en mémoire, d'accord. Mais quelle est la valeur de la variable à ce moment-là ? Y a-t-il une valeur par défaut (par exemple 0) ?

Eh bien, accrochez-vous : la réponse est non. Non, non et non, il n'y a pas de valeur par défaut. En fait, l'emplacement est réservé mais la valeur ne change pas. On n'efface pas ce qui se trouve dans la « case mémoire ». Du coup, votre variable prend la valeur qui se trouvait là avant dans la mémoire, et cette valeur peut être n'importe quoi !

Si cette zone de la mémoire n'a jamais été modifiée, la valeur est peut-être 0. Mais vous n'en êtes pas sûrs, il pourrait très bien y avoir le nombre 363 ou 18 à la place, c'est-à-dire un reste d'un vieux programme qui est passé par là avant !
Il faut donc faire très attention à ça si on veut éviter des problèmes par la suite. Le mieux est d'initialiser la variable dès qu'on la déclare. En C, c'est tout à fait possible. En gros, ça consiste à combiner la déclaration et l'affectation d'une variable dans la même instruction :

int nombreDeVies = 5;

Ici, la variable nombreDeVies est déclarée et prend tout de suite la valeur 5.
L'avantage, c'est que vous êtes sûrs après que cette variable contient une valeur correcte, et pas du n'importe quoi.

Les constantes

Il arrive parfois que l'on ait besoin d'utiliser une variable dont on voudrait qu'elle garde la même valeur pendant toute la durée du programme. C'est-à-dire qu'une fois déclarée, vous voudriez que votre variable conserve sa valeur et que personne n'ait le droit de changer ce qu'elle contient.

Ces variables particulières sont appelées constantes, justement parce que leur valeur reste constante.

Pour déclarer une constante, c'est en fait très simple : il faut utiliser le mot const juste devant le type quand vous déclarez votre variable. Par ailleurs, il faut obligatoirement lui donner une valeur au moment de sa déclaration comme on vient d'apprendre à le faire. Après, il sera trop tard : vous ne pourrez plus changer la valeur de la constante.

Exemple de déclaration de constante :

const int NOMBRE_DE_VIES_INITIALES = 5;

À part ça, une constante s'utilise comme une variable normale, vous pouvez afficher sa valeur si vous le désirez.
La seule chose qui change, c'est que si vous essayez de modifier la valeur de la constante plus loin dans le programme, le compilateur vous indiquera qu'il y a une erreur avec cette constante.

Les erreurs de compilation sont affichées en bas de l'écran (dans ce que j'appelle la « zone de la mort », vous vous souvenez ?). Dans un tel cas, le compilateur vous afficherait un mot doux du genre : [Warning] assignment of read-only variable 'NOMBRE_DE_VIES_INITIALES' (traduction : « Triple idiot, pourquoi tu essaies de modifier la valeur d'une constante ? »).

Afficher le contenu d'une variable

On sait afficher du texte à l'écran avec la fonction printf.
Maintenant, on va voir comment afficher la valeur d'une variable avec cette même fonction.

On utilise en fait printf de la même manière, sauf que l'on rajoute un symbole spécial à l'endroit où l'on veut afficher la valeur de la variable. Par exemple :

printf("Il vous reste %d vies");

Ce « symbole spécial » dont je viens de vous parler est en fait un '% suivi d'une lettre (dans mon exemple, la lettre 'd'). Cette lettre permet d'indiquer ce que l'on doit afficher. 'd' signifie que l'on souhaite afficher un int.
Il existe plusieurs autres possibilités, mais pour des raisons de simplicité on va se contenter de retenir celles-ci :

Format

Type attendu

"%d"

int

"%ld"

long

"%f"

float

"%f"

double

Je vous parlerai des autres symboles en temps voulu. Pour le moment, retenez uniquement ceux-ci ;)

On a presque fini. On a indiqué qu'à un endroit précis on voulait afficher un nombre entier, mais on n'a pas précisé lequel ! Il faut donc indiquer à la fonction printf quelle est la variable dont on veut afficher la valeur.
Pour ce faire, vous devez taper le nom de la variable après les guillemets et après avoir rajouté une virgule, comme ceci :

printf("Il vous reste %d vies", nombreDeVies);

Le %d sera remplacé par la variable indiquée après la virgule, à savoir nombreDeVies.
On se teste ça dans un programme ?

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
  int nombreDeVies = 5; // Au départ, le joueur a 5 vies
  
  printf("Vous avez %d vies\n", nombreDeVies);
  printf("**** B A M ****\n"); // Là il se prend un grand coup sur la tête
  nombreDeVies = 4; // Il vient de perdre une vie !
  printf("Ah desole, il ne vous reste plus que %d vies maintenant !\n\n", nombreDeVies);
  
  return 0;
}

Ça pourrait presque être un jeu vidéo (il faut juste beaucoup d'imagination).
Ce programme affiche ceci à l'écran :

Vous avez 5 vies
**** B A M ****
Ah desole, il ne vous reste plus que 4 vies maintenant !

Vous devriez reconnaître ce qui se passe dans votre programme.

  1. Au départ le joueur a 5 vies, on affiche ça dans un printf.

  2. Ensuite, le joueur prend un coup sur la tête (d'où le BAM).

  3. Finalement il n'a plus que 4 vies, on affiche ça aussi avec un printf.

Bref, c'est plutôt simple.

Afficher plusieurs variables dans un même printf

Il est possible d'afficher la valeur de plusieurs variables dans un seul printf. Il vous suffit pour cela d'indiquer des %d ou des %f là où vous voulez, puis d'indiquer les variables correspondantes dans le même ordre, séparées par des virgules.

Par exemple :

printf("Vous avez %d vies et vous etes au niveau n° %d", nombreDeVies, niveau);

Allez, un petit test maintenant. Notez que j'enlève les lignes tout en haut (les directives de préprocesseur commençant par un #), je vais supposer que vous les mettez à chaque fois maintenant :

int main(int argc, char *argv[])
{
  int nombreDeVies = 5, niveau = 1;
  
  printf("Vous avez %d vies et vous etes au niveau n° %d\n", nombreDeVies, niveau);
  
  return 0;
}

Ce qui affichera :

Vous avez 5 vies et vous etes au niveau n° 1

Récupérer une saisie

Les variables vont en fait commencer à devenir intéressantes maintenant. On va apprendre à demander à l'utilisateur de taper un nombre dans la console. Ce nombre, on va le récupérer et le stocker dans une variable.
Une fois que ça sera fait, on pourra faire tout un tas de choses avec, vous verrez.

Pour demander à l'utilisateur d'entrer quelque chose dans la console, on va utiliser une autre fonction toute prête : scanf.
Cette fonction ressemble beaucoup à printf. Vous devez mettre un format pour indiquer ce que l'utilisateur doit entrer (un int, un float, ...). Puis vous devez ensuite indiquer le nom de la variable qui va recevoir le nombre.

Voici comment faire par exemple :

int age = 0;
scanf("%d", &age);

On doit mettre le %d entre guillemets.
Par ailleurs, il faut mettre le symbole & devant le nom de la variable qui va recevoir la valeur.

Euh, pourquoi mettre un & devant le nom de la variable ?

Là, il va falloir que vous me fassiez confiance. Si je dois vous expliquer ça tout de suite, on n'est pas sortis de l'auberge, croyez-moi !
Que je vous rassure quand même : je vous expliquerai un peu plus tard ce que signifie ce symbole. Pour le moment, je choisis de ne pas vous l'expliquer pour ne pas vous embrouiller, c'est donc plutôt un service que je vous rends là !

double poids = 0;
scanf("%lf", &poids);

Revenons à notre programme. Lorsque celui-ci arrive à un scanf, il se met en pause et attend que l'utilisateur entre un nombre. Ce nombre sera stocké dans la variable age.

Voici un petit programme simple qui demande l'âge de l'utilisateur et qui le lui affiche ensuite :

int main(int argc, char *argv[])
{
  int age = 0; // On initialise la variable à 0
  
  printf("Quel age avez-vous ? ");
  scanf("%d", &age); // On demande d'entrer l'âge avec scanf
  printf("Ah ! Vous avez donc %d ans !\n\n", age);
       
  return 0;
}
Quel age avez-vous ? 20
Ah ! Vous avez donc 20 ans !

Le programme se met donc en pause après avoir affiché la question « Quel age avez-vous ? ». Le curseur apparaît à l'écran, vous devez taper un nombre entier (votre âge). Tapez ensuite sur « Entrée » pour valider, et le programme continuera à s'exécuter.
Ici, tout ce qu'il fait après c'est afficher la valeur de la variable age à l'écran (« Ah ! Vous avez donc 20 ans ! »).

Voilà, vous avez compris le principe. Grâce à la fonction scanf, on peut donc commencer à interagir avec l'utilisateur.

Notez que rien ne vous empêche de taper autre chose qu'un nombre entier :

  • si vous rentrez un nombre décimal, comme 2.9, il sera automatiquement tronqué, c'est-à-dire que seule la partie entière sera conservée. Dans ce cas, c'est le nombre 2 qui aurait été stocké dans la variable ;

  • si vous tapez des lettres au hasard (« éèydf »), la variable ne changera pas de valeur. Ce qui est bien ici, c'est qu'on avait initialisé notre variable à 0 au début. De ce fait, le programme affichera « 0 ans » si ça n'a pas marché. Si on n'avait pas initialisé la variable, le programme aurait pu afficher n'importe quoi !

En résumé
  • Nos ordinateurs possèdent plusieurs types de mémoire. De la plus rapide à la plus lente : les registres, la mémoire cache, la mémoire vive et le disque dur.

  • Pour « retenir » des informations, notre programme a besoin de stocker des données dans la mémoire. Il utilise pour cela la mémoire vive. Les registres et la mémoire cache sont aussi utilisés pour augmenter les performances, mais cela fonctionne automatiquement, nous n'avons pas à nous en préoccuper.

  • Dans notre code source, les variables sont des données stockées temporairement en mémoire vive. La valeur de ces données peut changer au cours du programme.

  • À l'opposé, on parle de constantes pour des données stockées en mémoire vive. La valeur de ces données ne peut pas changer.

  • Il existe plusieurs types de variables, qui occupent plus ou moins d'espace en mémoire. Certains types comme int sont prévus pour stocker des nombres entiers, tandis que d'autres comme double stockent des nombres décimaux.

  • La fonction scanf permet de demander à l'utilisateur de saisir un nombre.

Exemple de certificat de réussite
Exemple de certificat de réussite