=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Tutorial Turbo Pascal Ad-Tonnou =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= ************************************** ** TUTORIAL TURBO PASCAL (Ad-Tonnou)** ************************************** Salut, c'est ad-tonnou, me revoilou pour un article qui, cette fois, traitera d'un language de programmation qui me tiend à coeur, j'ai nommé le turbo-pascal... Cet article est le premier d'une longue serie qui traiteront tous de ce sujet, la difficulté allant bien sur en augmentant... Personnelement, j'utilise TP 6.0 pour compiler et editer tous mes progs, je ne vais pas en expliquer l'utilisation car elle est assez intuitive... Vu qu'il faut commencer par le debut, on va tout d'abbord commencer par la base: la structure d'un programme...puis on verra un exemple de prog et enfin les differentes types de declarations.... I)LA STRUCTURE D'UN PROG """""""""""""""""""""""" TurboPascal comme bien des languages (tous ?) est un language très structuré, la systématique en question fut developpée durant les années 60 par Dijkstra. a)STRUCTURE GENERALE °°°°°°°°°°°°°°°°°°°° Un programme en TurboPascal se compose de 4 parties bien delimitables: --> L'en-tête (indispensable) --> L'instruction Uses (pas obligé) --> La Partie Déclarative (pas obligé) --> Le corps principal du prog (indispensable) L'en tête: Contient seulement le mot réservé 'program' et du nom du prog L'instruction Uses: Cette partie contient les noms des unités que le prog utilisera et que le compilateur integrera...(en gros les unités sont les "bibliothèques" dans lesquelle le compilateur ira chercher les signification des mots réservés...heu je sais c'est po tres clair) La partie declarative: Cette partie contient la declaration des identificateurs utilisés lors de la suite du prog, par exemple les constantes, les variables...elles doivent imperativement y être présente pour la bonne demarche du prog par la suite. Le corp principal du prog: Celui debute par le mot reservé 'Begin' et se termine par le mot 'end.' ( !!!---> le point est partie integrante du mot) En quelques sortes c'est ici que vous direz au prog ce qu'il doit faire... b)REMARQUES °°°°°°°°°°°° Commentaires: On peut mettre dans le code source des commentaires, c'est à dire des remarques que le compilateurs ne prendra pas en compte lors de la transcription du code. Ils sont tres utiles et ils ne faut pas les négliger...notamment utiles lors de la diffusion de votre source pour une meilleure compréhension du prog par d'autres personnes. Ils figurent entre accolades... exemple: {ceci est un commentaire} Conseils: L'utilisation de majuscules dans le code permet également une meilleure compréhension.. exemple 'unmotlong' ecrit comme ceci est moins lisible que comme cela 'UnMotLong' Divers: Les instructions se terminent toujours par un ';' !!!! c)EXEMPLE °°°°°°°°°° Structure général d'un prog en TurboPascal (les mots clés sont en majuscules pour plus de lisibilité.. PROGRAM nom du prog {en tête} USES unit1,unit2....unitn {Uses } {--------------------------------------------} {----début le la partie déclarative----------} CONST {les constantes} TYPE {type de données} VAR {variables puis procédures et fonctions (sous-programmes) } {-----fin de la partie déclarative---------} {------------------------------------------} BEGIN {début du corp principal} {differentes instructions dites 'corporelles'} END. {fin du corp principal} d)MOTS CLEFS °°°°°°°°°°°°° Ces mots clés ont une signification particuliere,'write'(permet l'affichage) en est un... Ils appartiennent au vocabulaire de TurboPascal Les utilisateurs (nous) peuvent créer leurs propres identificateurs (qui peuvent être des variables, des constantes, des procédures...) Les identificateurs peuvent être aussi longs que vous le voulez, se composer des characteres suivants:les lettres et les chiffres... (chiffres interdits en début d'identificateur, les '.' et ',' sont interdites tout comme les charactères spéciaux...) CF: IV) II) L'UNITE CRT """"""""""""""" TRES TRES IMPORTANTE est cette unité. En effet elle permet de gérer les routines suivantes: Clrscr (efface l'écran), GotoXY (place le curseur aux coordonnées XY), ReadKey (permet de lire un charactere), KeyPressed (attente de l'appui d'un touche) et de plus l'unité CRT permet de gerer la solicitation du clavier.... L'intruction USES s'ecrit alors de la sorte USES crt; Le compilateur integrera donc la bibliotheque 'crt'. III) EXEMPLE SIMPLE """"""""""""""""""" Enoncé du problème: 'lire' deux chiffres A et B, les additionner et écrire la somme A+B à l'écran... On peut d'ores et déja diviser cette tache en plusieurs parties correspondant à des instructions simples: Effacer l'écran Lire A puis B Effectuer la SOMME A+B Afficher SOMME QUITTER Ceci pourrait se traduire par le code suivant... ETAPE 1: ClrScr; {efface l'écran} Readln(A); {lit A à partir du clavier puis va a la ligne,'READ' fait la même chose sans le retour à la ligne} ReanLn(B); SOMME := A + B; {on affecte la valeur 'A + B' a l'identificateur 'SOMME' avec le signe :=} WriteLn(SOMME); {affiche la valeur contenue dans l'identificateur 'SOMME' c'est à dire READLN; {j'y reviendrai} ETAPE 2: Il nous faut rajouter les instruction 'Begin' et 'End.' en début et en fin de corp...le corp du prog est le code de l'etape1 ETAPE 3: Nous employons ici 3 variables (A,B et SOMME, ce sont des variables car elles dependent de l'utilisateur), il nous faut donc les déclarer dans la section déclarative...(!!! ---> IMPERATIF) VAR A,B,SOMME : INTEGER; {j'y reviendrai} Les variables de mêmes types sont séparées par une virgule, et le type des variables se distingue par un ':' cas général: Var1,Var2 : Type1; Var3,Var4 : Type2; ETAPE 4: Il faut maintenant rajouter l'en-tête: le mot 'program' et le nom du prog) et l' instruction Uses Ici on utilisera la bibliotheque 'crt' car on utilise la routine 'clrscr' ETAPE 5: Nous obtenons finalement ce code: ---------------------------------------- {debut du prog} Program Addition; {En-tête} USES Crt; {uses} Var {partie déclarative} A,B,SOMME : Integer; Begin {corp principal du prog} Clrscr; Readln(A); Readln(B); SOMME:= A + B; Writeln(SOMME); Readln; End. {fin du prog} ----------------------------------------- ReadLn --> L'instruction Readln sert à faire attendre le programme l'appui de la touche 'ENTREE' Ne l'ommetez pas car sinon l'affichage de la somme se fera si rapidement que vous n'aurez rien le temps de voir. Grace a readln le prog affiche la somme puis attend la touche entrée avant de quitter et de revenir a l'editeur. L'instruction Write (ou writeln) permet de melanger l'affichage de charactères à l'affichage de variables...et ceci par write('charactere',VAR,'characteres',VAR) Exemple ---> WriteLn('la somme de ',A,'et de ',B,'est egale à ',SOMME) en admettant que A=2 et B=4 l'affichage donnera : la somme de 2 et de 4 est de 6. Ainsi si on essaye de donner un peu plus d'allure a notre programme on pourrait faire ceci... --------------------------------------------------------------- Program Addition; Uses CRT; Var A,B,SOMME : integer; Begin Writeln('Bienvenue dans mon super prog....) Writeln('veuillez entrer le chiffre A plizzzz...') read(A); Writeln('Veuillez entrer le chiffre B plizzzz...'); read(B); Writeln('La somme de ',A,'et de ',B,' est égale à',SOMME); Writeln('veuillez appuyer sur entrée pour quitter'); readln; End. --------------------------------------------------------------- Ce prog est fourni avec le zip... Maintenant on va passer à un point très important.... IV)DECLARATION DE CONSTANTES ET DE VARIABLES """""""""""""""""""""""""""""""""""""""""""" Maintenant que l'on a vu la structure générale d'un prog en turopascal, on peut passer à la suite... On va voir plus precisement la partie déclarative d'un prog, et ce qu'elle paut contenir... TurboPascal possede un mot réservé par type de déclaration: variables,constantes.... La partie déclarative est importante: RIEN NE PEUT ETRE UTILISE DANS UN PROG EN TP SANS QU IL N AIT ETE DECLARE AUPARAVANT... Cette partie debute par la fin de l'instruction USES et se termine la ou commence le corp du prog (begin) Deux types de déclarations sont indispensables pour la suite: les variables et les constantes... a)les constantes °°°°°°°°°°°°°°°° Les constantes sont des "données" qui ne varieront en aucun cas lors de l'execution du programme... La partie déclarative de constantes débute par le mot clé 'CONST' Suit l'identificateur (le nom de votre choix qui sera affecté de la valeur de votre choix) puis la valeur afféctée à cet identificateur: CONST Identificateur1 = Valeur1; Identificateur2 = Valeur2; Par la suite du prog, l'identificateur1 aura donc pour valeur la valeur1. le code 'write(identificateur1)' donnera donc a l'affichange la valeur 1. Les valeurs peuvent être des valeurs numériques ou bien des charactères et même des chaines de characteres. EXEMPLE aX = 'allianX' {chaine de ch} PI = 1,14 {valeur numérique} On apelle 'contenue' la valeure d'une constante...ainsi le contenu de 'aX' est la chaine de chaactere 'allianX' Choisissez des noms simples et courts pour vos identificateurs, cela simplifie grandement les choz. Exemple ---> un prog qui se sert du taux de la tva: Je vais po le faire mais il est bien facile de piger pourquoi il est utile de declarer ce taux en tant que constante des le debut du prog. Ainsi, vous n'aurez pas a tout modifier en cas de changement de ce taux, mais simplement le debut, la partie declarative de constantes, c'est a dire qu'une seule ligne. b)Les variables °°°°°°°°°°°°°°° Les variables sont des identificateurs auxquels on peut affecter des chiffres, des lettres, des chaines de characteres... Une variable se definit par 3 elements : Son nom - Son type de donnée - Son contenu Dans la partie déclarative, une variable recoit son nom, et son type de donnée... Son contenu ne sera qu'affectée au cours de l'execution du prog..(défini par l'utilisateur) La partie déclarative d'une variable dbute par le mot reservé 'VAR'..puis le(s) nom(s) de(s) variable(s), on sépare les noms de variable de mêmes types par une virgule....et on met un ':' entre les(s) nom(s) et le type de donnée. Exemple: ----------------------------- VAR var1,var2 : type1; var2 : type2; ------------------------------ Ici var1 et var2 ne sont pas encore attibuées d'un contenu...on leur donne juste leur type de donnée.(CF Article2) Attention a ne pas oublier le ';' car l'attribution d'un type à une variable est un instruction. Voici la maniere d'affecter une valeur à un contenu: ------------------------------ NomVar:=valeur ------------------------------ le symbole ':=' est le symbole d'affectation d'une valeur à une variable Exemple: ------------------------------ a := 9; b :='allianX'; ------------------------------ Vous ne pouvez faire cela sans avoir auparavant declarer les variables a et b dans la partie déclarative de variables. Voila, le premier article est fini. Forcement c'est lourd mais il faut savoir tout ça pour pouvoir faire des trucs plus sympas... J'en ai mis deux autres dans le zine pour trois raisons: Vous avez déjà un bon paquet d'informations à assililer, si vous pigez pas, relisez plusieurs fois; c'est important. Pour plus de clarté j'ai divisé mon petit premier tutorial en trois articles... J'en ai ral le cul d'écrire des conneries...je continuerai demain... --== Ad-Tonnou pour vous servir ==-- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Tutorial Turbo Pascal 2 Ad-Tonnou =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= *************************************** ** TUTORIAL TURBO PASCAL (Ad-Tonnou) ** *************************************** Nous voila reparti pour un deuxieme article de folie... Celui-ci sera consacré aux différents types de données en turbo pascal et quelques fonctions de bases appliquables sur ceux-ci puis des petits trucs simples divers... Pour lire cet article vous devez avoir pigé le premier """""""""""""""""""""""""""""""" " LES TYPES DE DONNEES SIMPLES " """""""""""""""""""""""""""""""" En Turbo Pascal, on compte 5 types de données simples: Les nombres entiers (INTEGER) Les nombres décimaux (REAL) Les charactères (CHAR) Les chaînes de charactères (STRING) Les valeurs logiques (BOOLEAN) Les variables, lors de leur déclaration, doivent se voir attribuer d'un des 5 types précedents. Sur chacun des ces types, on peut effectuer des opérations de comparaison (très utiles): > (superieur à) < (inferieur à) >= (superieur ou égal) <= (inferieur ou egal) = (égal à) <> (différent) I)Les Nombres Entiers (INTEGER) """"""""""""""""""""""""""""""" a)les bases °°°°°°°°°°° Domaine de validité des INTEGER: -32768..........32767 Opérations possibles: Les comparaisons L'addtion + La soustraction - Multiplication * La division DIV (résultat entier, pas de décimales) Le modulo MOD (Le reste de la division) Exemples: 10+8=18 20-3=17 5*9=45 45 DIV 5=9 45 MOD 5=0 45 DIV 6=7 45 MOD 6=3 (on divise 45 par 6, on a (6*7)+3=45) Turbo Pascal offre la possibilité d'effectuer quelques procédures standarts sur les differents types de données...pas d'inquietude, vous allez comprendre: b)Fonctions standarts sur des variables du type INTEGER °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° Soit A une variable de type REAl Soit B une variable de type INTEGER ABS(B) donne la valeur absolue de la variable B Le résultat est du type INTEGER Appel: Result:=ABS(B); Exemple: Result:=ABS(-5); La variable 'Result' est alors affecté de la valeur 5. ROUND(A) donne la valeur arrondie entière de la variable A Le résultat est de type INTEGER Appel: Result:=ROUND(A); Exemple: Result:=ABS(5.8); La variable 'Result' est affecté de la valeur 6 SQR(B) donne le quarré de la variable B Le résultat est de type INTEGER Appel: Result:=SQR(B); Exemple: Result:=SQR(3); La variable 'Result' est affecté de la valeur 9 TRUNC(A) donne la partie entière de la variable A...attention elle n'est pas arrondie! Le resultat est du type INTEGER Appel: Result:=TRUNC(A); Exemple: Result:=TRUNC(5.8); La variable 'Result' est affecté de la valeur 5 II)LES NOMBRES REELS (REAL) """"""""""""""""""""""""""" a)les bases °°°°°°°°°°° Domaine de validité: 2.9*10^-39..............1.7*10^38 Déclaration: --------------------- VAR exemple : real --------------------- Opérations possibles: Les mêmes que pour les INTEGER La division est possible avec les REAL, / (le résultat est du type REAL) b)Fonctions standarts sur des variables du type REAL °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° Soit A une variable de type real Soit Result une variable du type du résultat ABS(A) donne la valeur absolue de la variable A Le résultat est du type REAL Appel: Result:=ABS(A); Exemple: Result:=ABS(-5.8); Alors la variable Result est affectée de la valeur 5.8 COS(A) donne le cosinus de la variable A...attention le résultat est exprimé en Radian Le résultat est du type REAL Appel: Result:=COS(A); Exemple: Result:=COS(pi); La variable Result est affectée de la valeur 1.00 SIN(A) donne de la même facon le sinus de la variable A FRAC(A) donne la valeur décimale de la variable A Le résultat est du type REAL Appel: Result:=FRAC(A) Exemple: Result:=FRAC(5.123456) La variable Result sera alors affectée de la valeur 0.123456 INT(A) quand à elle donne la partie entière de la variable A...c'est pareil que FRAC Exemple: Result:=INT(5.123456) la varible Result sera alors affectée de la valeur 5. SQR(A) donne le carré de A Le resultat est du même type que la varible A Exemple: Result:=SQR(2) La variable Result sera alorsd affectée de la valeur 4 SQRT(A) donne la racine carré de A Exemple: Result:=SQRT(4) La variable Result sera alors affectée de la valeur 2 c)Sortie formatée °°°°°°°°°°°°°°°°° Examinons ce code... ------------------------------ Program test1; Uses CRT; VAR A:REAL; Begin Writeln('donnez moi la valeur de A'); Readln(A); Writeln('affichage normal.....',A); Writeln('Affichage formaté',A:5:2); End. ------------------------------- Admettons que la variable A soit affectée de la valeur 5.123456 Alors l'affichage normale donnera à l'écran: '5.1234560000e+00'...ce qui n'est pas très beau... Maintenant, l'affichage formaté donera: '5.12'... A:5:2 signifie que la varible A sera affichéé avec 2 chiffres apres la virgule (!!---> c'est atomatiquement arrondi) et que la variable A sera affichée sur un total de 5 chiffres. d)Petite appliquation °°°°°°°°°°°°°°°°°°°°° ------------------------------------------------------ program division; uses crt; var result : real; rest : real; A,B : integer; begin ClrScr; writeln('Bienvenue dans mon deuxieme super progz pour allianX'); writeln('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'); WriteLn('Veuillez me donner le chiffre dont vous voulez voir la division Euclydienne!!!'); readln(A); WriteLn('Par combien je le divise ??? '); ReadLn(B); Result := A DIV B; Rest := A MOD B; Writeln('Veuillez appuyer sur Entr‚e afin de continuer'); ReadLn; Write('Le resultat de la division de ',A,' par ',B,' donne:'); write(Result:4:0); write(' et le reste est de '); writeln(rest:4:0); {cf article 2, "affichage format‚"} write('Appuyez sur Entree pour quitter...'); ReadLn; End. --------------------------------------------------------- J'espère que vous comprenez car là je passe à la suite...surtout que c'est vraiment bidon. III)Les charactères (CHAR) """""""""""""""""""""""""" Ce type de données s'applique à tous les charactères du code ASCII (American Standart Code for Information Interchange). Ce code comprend tous les charactères de votre clavier plus tous les charactères graphique... Tous ces charactères sont représentés par un chiffre...compris entre 0 et 255 inclus. a)Les bases °°°°°°°°°°° On peut affecter un charactère à une constante: -------------------------- CONST A = 'a'; {la variable A est affectée du charactère 'a'} ---------------------------- Déclaration du type char ------------------ VAR ch:char; {alors la variable de nom 'ch' sera affecté du type 'char'} ------------------ Ce code est contenu dans la partie déclarative du progz...il permettra donc par exemple d'affecter par la suite une valeur à la variable ch...cette valeur étant bien entendu de type 'char' -------------------- ch:='y'; {alors la variable 'ch' est affectée de la valeur 'y'} ch:='chaine'; {cela ne marchera pas car 'chaine n'est pas un charactère mais une chaine de charactères} -------------------- Les opérations possible sont les opérations de comparaison...on les a déjà vues au-dessus... b)Les fonctions standarts possibles sur les variables de type 'CHAR' °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° Soit 'ch' une variable du type char... I est une variable de type INTEGER.... La variable 'result' est du type du resultat CHR(I) retourne le charactere dont le code ascii/ibm est de I Appel: RESULT:=CHR(I); Exemple: RESULT:=CHR(65); La variable 'RESULT' est alors afféctée de la valeur 'a' ORD(CH) retourne le code du charactere 'CH' Appel: RESULT:=ORD(CH); Exemple: RESULT:=ORD('A'); La variable 'RESULT' sera alors affecté de la valeur 65 PRED(CH) donne le predecesseur de la variable CH Appel: RESULT:=PRED(CH); Exemple: RESULT:=PRED('b'); La variable result sera alors affectée de la valeur 'a' SUCC(CH) c'est comme PRED5CH° sauf qu'il donne le successeur IV)Les chaines de characteres (STRING) """""""""""""""""""""""""""""""""""""" a)les bases °°°°°°°°°°° C'est le regroupement de charactères de longueur maximale de 255 charactères... Le type s'apelle STRING Déclaration de variables de type STRING (dans la partie déclarative bien sur) ------------------------------ var st:string; ------------------------------ On peut limiter la longueur maximale d'une chaine...en indiquant une valeur entiere a la suite du mot réservé STRING ------------------------------ var st:string[10]; ------------------------------ Déclarations de constantes en tant que textes: ------------------------------ Const ax:='allianX'; ad:='ad-toto'; ------------------------------ (notez les '', et le signe d'affectation ':=') On peut aussi acceder à un seul charactere dans une string... ------------------------------ ax:='allianX'; write(ax[7]); ------------------------------ L'affichage donnera alors à l'écran 'X'. (le 7ème charactere de la string 'allainX'.) Les opérations possibles sur des string sont les comparaisons et les concaténations... Exemple de prog mettant bout à bout (c'est ça la concatenation) deux strings ------------------------------ Program concatene; var st1,st2:string; st3:string; begin clrscr; st1:='team'; st2:='allianX'; writeln('voici la 1ere chaine',st1); writeln('voici la 2eme chaine',st2); st3:=st2 + st1; writeln('voici leur concatenation',st3); readln; end. ------------------------------ b)fonctions standarts sur les strings °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°° CONCAT(ST,ST1) met bout a bout plusieurs chaines (ici st et st1) appel: concat(st,st1...); exemple: st:='turbo'; st1:='pascal'; result:=concat(st,st1); La variable 'result' sera alors affecte de la valeur (de type string) 'turbo pascal' COPY(ST,I,J) copie une partie de longueur J de la chaine ST a partir de la position I appel: concat(st,i,j); exemple: st:=ad-tonnou; result:=copy(st,4,6); Le resultat sera alors affecte de la valeur 'tonnou' DELETE(ST,I,J) efface J characteres a partir de I dans la chaine ST. appel: delete(st,i,j); exemple: st:='ad-tonnou'; delete(st,4,6); write(st) L'affichage donnera alors 'ad-' (puisque 'tonnou' s'est fait deleté) INSERT(st,st1,I) insere la chaine st dans la chaine st1 a partir de la position I Appel: INSERT(st,st1,I); exemple: insert('-t','adonnou',2); write(st1); retournera alors la chaine 'ad-tonnou' LENGTH(ST) retourne la longueur de la variable ST. exemple: result:=length('ad-tonnou'); La variable 'RESULT' sera alors affectée de la valeur 9. (result doit etre declare en tant que integer) Voila en gros les bases sur les strings....voyons maintenant le type 'boolean'. V)Les valeurs logiques (boolean) """""""""""""""""""""""""""""""" a)les bases °°°°°°°°°°° Une variable de type Boolean ne peut recevoir que 2 valeurs: true (vrai) ou false (faux) Une opération du type a>b retourne le resultat true si a>b false si a= > est l'operateur et A et B sont les operandes) Syntaxe de déclaration d'une variable de type BOOLEAN --------------------------- var test:boolean; --------------------------- Les operations possibles sur les BOOLEANS: --> les operations de comparaison (seulement quand false A and B (et logique) --> A or B (ou logique) --> A XOR B (ou exclusif) --> NOT A (nona, negation de A) Une seule fonction standart: ODD(I) retourne true quand I est impair (I est ici integer) exemple: result:=ODD(16)... La variable 'result' est alors affectee de la valeur 'false' car 16 est paire. VOILA !! Vous savez les bases (de bonnes bases) à propos des differents types de donnees de TurboPascal. Je vais eclaircir quelques points qui je pense sont importants.... VI)Les instructions d'entree READ/READLN """""""""""""""""""""""""""""""""""""""" Ces commandes permettent de transmettre des valeurs a un programme par l'intermediaire du clavier. ----------------------- READLN(X) ----------------------- Cette commande attend de l'utilisateurs l'entree d'une valeur au clavier (depend du type de X). Si X est du type 'CHAR' et que vous entrez la valeur '5', cela vous conduira systematiquement a une erreur (il faudra penser par exemple a integrer des routines interceptant les messages d'erreurs...ce sera pour plus tard) Dans les exemples precedants, j'avais mis readln a la fin du code afin d'arreter le prog jusqu'a l'appui sur 'entree'. Exemple tout con general ---------------------- write('quel est ton nom ???'); readln(nom); ---------------------- L'utilisateur comprendra qu'il doit indiquer son nom... (L'instruction read est utile pour lire des trucs a partir d'autres files mais la on parle de solicitation des users, donc on reste a readln....) Exemple encore tout con de l'utilisation simple de 'WRITE' et de 'READLN'... ------------------------------------------------------ program con; uses crt; var prenom:string[15]; {le prenom, pas plus que 15 characteres} age:integer; {l'age} chiffre1,chiffre2,chiffre3:integer; begin write('c koa ton nom ??'); readln(Prenom); write(prenom,'c koa ton age ???'); readln(age); write('indic moi 2 chiffres ! '); readln(chiffre1);readln(chiffre2); chiffre3:=chiffre1+chiffre2; writeln(prenom,'tu as ',age,' ans et la somme entre',chiffre1,' et ',chiffre2,' est ',chiffre3); write('appuis sur entree pour sortir'); readln; end. ------------------------------------------ VII)La commande 'READKEY' """"""""""""""""""""""""" Certains progs necessitent l'appui d'une touche sur le clavier mais sans pour autant que celle ci s'affiche (sans echo) L'appel est de cette forme: ------------------------------- ch:=readkey; ------------------------------- (la variable ch doit etre declaree auparavant en tant que charactere) La touche pressee est enregistree en tant que valeur de 'CH' mais n'est pas affichee pour autant. exemple con: ---------------------------------- progam readkey uses crt; var ch:char; begin clrscr writeln('appuyez sur une touche'); ch:=readkey; {ch est alors affectee de la valeur 'lettre lu' mais rien ne s'affiche} writeln('touche lue:'ch); readln; end. VOILA !!!! C'est fini, le prochain episode traitera des boucles et de la programmation en TP orientée decisions... --== Ad-Tonnou pour vous servir ==--