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 2 choses :
- Elle a une valeur : c'est le nombre qu'elle stocke, par exemple 5.
- Elle a 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 !), on va juste indiquer des noms de variables à la place. C'est le compilateur qui fera la conversion entre le nom et l'adresse. Voilà déjà un souci en 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 lettres minuscules et majuscules et des chiffres (abcABC012...).
- Votre nom de variable doit commencer par une lettre.
- Les espaces sont interdits. A 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 (comme le 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 3 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 variable corrects : nombreDeVies, nombre_de_vies, 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'onde
Quoi que vous fassiez, faites en sorte de donner des noms clairs à vos variables. On aurait pu abréger nombreDeVies, en l'écrivant par exemple ndv. C'est peut-être plus court, mais c'est beaucoup moins clair pour vous quand vous relisez votre code. N'ayez donc pas peur de donner des noms un peu plus longs pour que ça reste compréhensible.
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 :
Mais il y a aussi des nombres décimaux, c'est-à-dire des nombres à virgule :
En plus de ça, il y a aussi des nombres entiers négatifs :
... Et des nombres négatifs décimaux !
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... Ca 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 (il y en aura un autre qui fera son apparition en C++) :
| Nom du type |
Nombres stockables |
| char |
-128 à 127 |
| int |
-2 147 483 648 à 2 147 483 647 |
| long |
-2 147 483 648 à 2 147 483 647 |
| float |
-3.4 x 10 puissance 38 à 3.4 x 10 puissance 38 |
| double |
-1.7 x 10 puissance 308 à 1.7 x 10 puissance 308 |
(Je suis loin d'avoir mis tous les types, mais j'ai conservé les principaux 
)
Les 3 premiers types (char, int, long) permettent de stocker des nombres entiers : 1, 2, 3, 4...
Les 2 derniers (float, double) permettent de stocker des nombres décimaux : 13.8, 16.911...
Vous remarquerez qu'int et un long ont l'air identiques. Avant ce n'était pas le cas (un int était plus petit qu'un long), mais aujourd'hui les mémoires ont évolué et on a assez de place pour stocker des grands nombres, donc on se moque un peu de la différence entre un int et un long. Le langage C "conserve" tous ces types pour des raisons de compatibilité, même si certains sont un peu de trop.
En pratique, j'utilise principalement char, int et double.
Vous verrez que la plupart du temps on manipule des nombres entiers (tant mieux, parce que c'est plus facile à utiliser
)
Attention avec les nombres décimaux ! Votre ordinateur ne connaît pas la virgule, il utilise le point. Vous ne devez donc pas écrire 54,9 mais plutôt 54.9 !
Ce n'est pas tout ! Pour les types stockant des entiers (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 à 4 294 967 295 |
| 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 nombre négatif, mais qui ont l'avantage de pouvoir stocker des nombres 2 fois plus grands (char s'arrête à 128, tandis que unsigned char s'arrête à 255 par exemple).
Pourquoi avoir créé 3 types pour les nombres entiers ? Un seul type aurait été suffisant non ?
Oui, mais on a créé plusieurs types à l'origine 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.
Et je dis ça sérieusement. Ne vous prenez pas trop la tête sur le choix d'un type pour le moment
En résumé, on fera surtout la distinction entre nombres entiers et décimaux :
- Pour un nombre entier, on utilisera le plus souvent int.
- Pour un nombre décimal, 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 d'indiquer dans l'ordre :
- Le type de la variable que l'on veut créer
- Tapez espace
- Indiquez le nom que vous voulez donner à la variable
- Et enfin n'oubliez pas le point-virgule
Par exemple, si je veux créer ma variable nombreDeVies de type int, je dois taper la ligne suivante :
Code : C
Et c'est tout !
Quelques autres exemples stupides pour la forme :
Code : C | int noteDeMaths;
double sommeArgentRecue;
unsigned int nombreDeZerosEnTrainDeLireUnNomDeVariableUnPeuLong;
|
Bon bref, vous avez compris le principe je pense
Ce qu'on fait là s'appelle une
déclaration de variable (un vocabulaire à retenir là
)
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 :
Code : C | #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) // Equivalent de int main()
{
// Début de la fonction
int nombreDeVies;
return 0;
// Fin de la fonction
}
|
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.
Soyez sans crainte donc, 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 :
Code : C
Rien de plus à faire. Vous indiquez le nom de la variable, un signe égal, puis la valeur que vous voulez mettre dedans.
Ici, on vient de donner la valeur 5 à la variable nombreDeVies.
Notre programme complet ressemble donc à ceci :
Code : C | #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. C'est pas magnifique ça ?
Pour un peu on en pleurerait
On peut s'amuser si on veut à changer la valeur par la suite :
Code : C | 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 :
Code : C
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 :
Code : C
Ici, la variable nombreDeVies est déclarée et elle 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 :
Code : C | const int NOMBRE_DE_VIES_INITIALES = 5;
|
Ce n'est pas une obligation, mais par convention on écrit les noms des constantes entièrement en majuscules comme je viens de le faire là. Cela nous permet ainsi de distinguer facilement les constantes des variables. Notez qu'on utilise l'underscore _ à la place de l'espace.
A 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 : "mais t'es vraiment idiot, pourquoi t'essaies de modifier la valeur d'une constante ?
" )
Un monde de variables
)
).
?
othmane94
mais rien ne se produit 
(plus de 10 min et rien)
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook