Le but de tout programme d'ordinateur est, dans l'absolu, de gérer des données et de leur y appliquer un traitement, et ce, même si l'application en question est en réalité un jeu, un lecteur de film ou de musique, ou n'importe quelle autre application envisageable.
Pour gérer ces données, il n'y a rien à faire, le programmeur doit disposer de deux informations capitales, qui sont, du point de vue de l'utilisateur un nom permettant de les identifier de manière unique et une valeur.
La manière permettant d'identifier les valeurs de manière unique s'appelle tout simplement, vous ne me croirez sans doute jamais, le nom de la variable.
Pour l'ordinateur, il y a trois informations capitales qui rentrent en ligne de compte pour gérer les données:
Tout cela m'amène naturellement à parler du typage des données.
La mémoire, en informatique, n'est qu'une succession de petits interrupeurs qui peuvent êtresoit ouverts, soit fermés.
Ces petit interrupteurs prennent le nom pompeux de "bit".
Si l'interrupteur laisse passer le courent, il prendra la valeur de "1", et, si, au contraire, il ne le laisse pas passer, il prendra la valeur de "0".
Le bit, bien qu'étant normalement d'office regroupé par huit, peut servir comme un premier type de valeur possible.
Le type de cette valeur s'appelle «booléen», en homage à cette logique qui essaie de n'arriver qu'à une réponse "vrai" ou "faux".
Il est à noter que tous les langages de programmation n'acceptent pas ce type de variable.
Quand huit bits sont pris ensembles (on parle alors d'octet), on dispose de 255 valeurs différentes, ce qui est tout juste suffisant pour permettre le codage de caractères en fonction de la norme ASCII (même si je soupçonne fortement qu'en fait la norme ASCII se soit basée sur 255 possibilités du fait que l'habitude était prise d'utiliser les octets).
Sur base de cette norme, il est possible de faire afficher l'ensemble des caractères nécessaires à un texte compréhensible.
Il est à noter qu'un autre ensemble de normes, permettent le support des tables de caractères propres à l'ensemble des langues existantes, mais que l'usage de cet ensemble de normes, bien plus compliqué, sort du contexte de ce tutorial.
Il s'agit de la norme de caractères iso-8859.
Pour effectuer des calculs sur des valeurs entières, on dispose de données codées du 16 ou 32 bits (autrement dit deux ou quatre octets) selon les systèmes (16 bits avec les processeurs 3x86 et 4x86, 32 bits sur les processeurs de type pentium).
Le «bit de poids fort», autrement dit, celui qui a la valeur la plus importante, peut, au choix du programmeur, représenter soit la présence ou l'absence du signe négatif, au quel cas nous parlerons d'entier signé, soit servir de valeur pour l'entier envisagé, au quel cas, nous parlerons d'entier non signé.
Les valeurs disponibles sur les processeurs 3x86 et 4x86 iront donc de 0 à 65 535 dans le cas d'entiers non signés et de -32 767 à +32 568 pour les entiers signés
Avec les processeurs de type pentium, les valeurs disponibles sont respectivement de 0 à 4 294 967 295 pour les entiers signés et de -2 147 483 647 à +2 147 483 648 pour les entiers signés.
Enfin, il est parfois nécessaire d'utiliser des valeurs non entières. Que l'on veuille simplement utiliser la valeur de PI (3.14159) ou n'importe quelle autre valeur avec des décimale, nous devrons avoir recours à des nombres connus sous le nom de «réel» ou de «nombres à virgules flottantes».
Selon les systèmes et la précision demandée, l'espace qu'utilise un tel nombre est susceptible de varier entre 64 et 80 bits (entre 8 et 10 octets).
Outre le type de valeur que l'on s'attend à trouver dans une variable, il est possible avec la plupart des langages de programamtion de classer les variables en deux grands types en fonction de l'endroit où elles sont disponibles dans le code.
En effet, une variable peut être disponible pour toute les routines d'un programme ou, au contraire, n'être disponible que pour une routine bien précise, et "oubliée" par le système dés que cette routine est quittée.
Cela signifie, entre autre, que la mémoire qui lui était allouée redeviendra disponible pour le système, mais donc, aussi, que la valeur qu'elle contenait sera perdue une fois que la routine sera quitée.
Les variables qui resteront accessibles pour toutes les routines d'un programme seront appelées «variable globales», alors que les variables qui ne sont accessibles que dans une routine bien précise seront logiquement appelées «variables locales».
Certains langage de programmation permettent même de déclarer des variables qui ne seraient disponibles, par exemple, que dans une boucle. Nous parlerons alors de variable «super-locale»
On pourrait donc être tenté de n'utiliser que des variables globales (ce que fait, entre autre le langage COBOL) de manière à ne pas devoir s'occuper de passer des paramètres aux différentes routines, et qui aurait l'avantage de pouvoir n'utiliser que des procédures.
Si ce calcul peut sembler intéressant à court terme, il peut l'être beaucoup moins à long terme.
En effet, il faut bien être conscient que si, dans une des routines que vous appelez, vous venez à modifier la valeur d'une variable globale, l'ancienne valeur sera irrémédiablement perdue et la modification de la valeurs sera définitive.
De plus, si vous devez déclarer toutes les variables dont vous aurez besoin dans une application complexe, vous serez non seulement obligé de choisir à chaque fois des noms différents (avec le risque de vous tromper dans une routine et de modifier la valeur d'une variable différente que celle que vous le vouliez).
Enfin, la multiplication des variables mobilisera fatalement en permanence des ressources bien plus importantes que si vous utilisiez des variables locales, ressources qui pourraient à terme venir à manquer.
Le meilleur compromis se trouve donc en la déclaration globale du stricte minimum des variables absolument indispensables et en la déclaration locale des variables qui ne sont nécessaires que dans une ou l'autre routine.
A lire ce titre, vous devez me prendre pour un fou, et pourtant…
Pour nous qui avons appris à compter dés notre plus jeune âge, "Un" vaut… 0+1 ou 3-2 ou tout ce que l'on peut souhaiter…
C'est sans compter que l'espace alloué pour le caractère 1 n'est que de 8 bits alors qu'il est de 16 (ou 32) bit s'il s'agit de la valeur entière un.
Et en plus, la valeur donnée au caractère 1 dans la norme ASCII est en réalité 48 (ou, en binaire sur 8bits 00110000) alors que la valeur de un pour l'ordinateur sera réellement en binaire de 0000000000000001 (ici, codée sur 16 bits, rajoutez juste 16 "0" à gauche du premier "0" pour l'avoir en 32)
De la meme manière, les caractères 12 (donc, respectivement le caractère 1 et le caractère 2) on des valeurs respectives de 48 et 49, donc, en binaire équivalente à 00110000 et 00110001 .
En mettant ces deux valeurs bout à bout, nous obtiendrions donc une valeur codée sur 16 bits, donc, susceptible d'être considérée comme un entier, mais d'une valeur réelle de 12 337… Ce qui est loin, vous en conviendrez de 12 qui prend en binaire la valeur 0000000000001100…
Par chance, les langages de programmation disposent de fonctions permettant de convertir la valeur d'un entier en son équivalent en caractère et inversément.
L'affichage de la valeur d'un entier provoquera d'ailleurs bien souvent la conversion de manière transparente pour le programmeur (exception faite du langage C, qui utilise une syntaxe particulière pour l'affichage).
Peut être êtes vous étonné du peu de types différents de données dont on dispose.
Si c'est le cas, vous vous demmandez sûrement comment on arrive alors à créer des chaines de caractères, voir des textes entiers.
La solution de base consiste en l'emploi de tableaux.
Plus loin dans ce tutorial, nous verrons comment regrouper des valeurs de types différents en créant des variables structurées, ou types personnalisés, mais il ne faut pas vouloir brûler les étapes.
Le but d'une variable est de fournir au programmeur l'accès à une valeur contenue en mémoire, et de lui permettre de faire changer cette valeur…
Comme la valeur peut… varier, il est logique d'appeler cet accès à la mémoire du nom de variable…
Cependant, l'utilisateur peut, avec certains langages de programmation, décider de définir une valeur qui ne pourra plus être modifiée tout au long de l'application qu'il est en train de créer.
Ce serait par exemple le cas de la valeur PI (3.14159) pour laquelle il n'existe aucune raison de la laisser modifer.
Nous nous trouverons alors en présence d'une variable… invariable (dont la valeur ne peut pas varier).
Les puristes nommeront cette variable spéciale «constante»
Quand vous déclarez une variable, vous demandez en réalité au système de réserver un espace suffisant en mémoire pour y mettre une valeur du type que vous choisissez.
Cet espace mémoire est, théoriquement du moins, libéré lorsque vous quittez l'application de manière à le rendre disponible pour plus tard.
Il s'en suit que vous ne pouvez en aucun cas être sûr à 100% que l'adresse mémoire réservée à une variable n'a pas été utilisée auparavant par une autre application, et, encore moins, de la valeur contenue dans cet emplacement de la mémoire.
Si vous essayez d'utiliser la valeur contenue dans la mémoire sans vous être assuré au préalable qu'elle contienne une informaiton pertinante, vous risquez très rapidement de vous trouver confronté à des incohérences dans l'application que vous créez.
Une bonne habitude à prendre est donc, de manière systématique, de fournir à chaque variable que vous déclarez une valeur qui soit en mesure de vous assurer que son appel malencontreux ne vous mènera pas au désastre.
Cette étape s'appelle l'initialisation des variables.
Copyright (©) 2005 (Philippe Dunski)
Ce cours est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
Ce cours est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
Cependant, l'auteur apprécierait grandement que vous lui fassiez part de toute modification apportée à son contnu
Vous pouvez le contacter par mail à l'adresse koala01@free.fr
Vous pouvez trouver une adaptation française de la licence GNU/GPL à l'URL http://www.linux-france.org/article/these/gpl.html
