Obligement - L'Amiga au maximum

Jeudi 28 mars 2024 - 13:52  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

Actualité (récente)
Actualité (archive)
Comparatifs
Dossiers
Entrevues
Matériel (tests)
Matériel (bidouilles)
Points de vue
En pratique
Programmation
Reportages
Quizz
Tests de jeux
Tests de logiciels
Tests de compilations
Trucs et astuces
Articles divers

Articles in english


Réseaux sociaux

Suivez-nous sur X




Liste des jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z,
ALL


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Galeries

Menu des galeries

BD d'Amiga Spécial
Caricatures Dudai
Caricatures Jet d'ail
Diagrammes de Jay Miner
Images insolites
Fin de jeux (de A à E)
Fin de Jeux (de F à O)
Fin de jeux (de P à Z)
Galerie de Mike Dafunk
Logos d'Obligement
Pubs pour matériels
Systèmes d'exploitation
Trombinoscope Alchimie 7
Vidéos


Téléchargement

Documents
Jeux
Logiciels
Magazines
Divers


Liens

Associations
Jeux
Logiciels
Matériel
Magazines et médias
Pages personnelles
Réparateurs
Revendeurs
Scène démo
Sites de téléchargement
Divers


Partenaires

Annuaire Amiga

Amedia Computer

Relec


A Propos

A propos d'Obligement

A Propos


Contact

David Brunet

Courriel

 


Programmation : Pascal - La structuration des programmes
(Article écrit par Olivier Garrigues et extrait d'Amiga News Tech - mai 1992)


Où l'on verra tous les outils que Pascal met à la disposition du programmeur pour boucler, "recorder", "procéduriser", "fonctionnaliser" et pointer à souhait...

Les boucles

FOR

C'est l'instruction d'itération sur indice. On l'utilise quand on veut qu'une valeur varie d'une façon continue et régulière, d'une valeur à une autre, soit en s'incrémentant, soit en se décrémentant d'un nombre de pas fixe. De plus, la valeur (indice de la boucle) ne devrait pas être modifiée dans le corps de la boucle. Toutes les valeurs sont de type entier (integer, short ou byte).

Remarque : "downto" est nécessaire si vous utilisez une valeur d'incrémentation négative, sinon la boucle est exécutée au moins une fois. Tout ce qui est entre crochet est optionel.

WHILE

C'est plus souple d'utilisation : tant que le booléen est vrai, on exécute le corps, sinon on passe à l'instruction suivante.

REPEAT... UNTIL

C'est proche de l'idée de WHILE : on repète les instructions jusqu'à ce que le booléen soit vrai. La différence (au-delà du fait de la négation du test) par rapport au WHILE, est que la boucle est exécutée au moins une fois, le test se faisant à la fin.

Pascal

Les enregistrements

Passons aux structures de Pascal. Elles sont un regroupement de variables servant à décrire un objet plus complexe. La spécification exige que cet ensemble de variables soit stocké dans un espace mémoire continu. Chaque champ (une variable) a son propre nom et chaque variable d'une structure (c'est-à-dire une variable qui représente l'objet plus complexe) possède bien sûr un nom. Il est souvent pratique, voire obligatoire pour des appels de procédures et de fonctions, de définir un type pour une structure.

Pascal

Les "records" (littéralement : enregistrements) sont très utilisés sur notre machine ; regardez les fichiers include, comme intuition.i.

Pascal

Vous remarquerez la commande WITH (en français "avec") : elle permet d'accéder aux champ de la variable passée en argument sans utilisation du point, ceci est plus rapide et normalement optimise le programme.

On peut normalement utiliser plusieurs fois, dans différentes structures, le même nom de champ. De plus, il est possible qu'une variable porte le nom d'un champ (ne pas trop le faire).

Une affectation est autorisée d'une variable structure à une autre si elles sont de même type. Seulement cette copie est une copie "bit-à-bit". En d'autres termes, aucune zone n'est allouée, mais deux pointeurs pointent sur la même zone (en cas de double libération, gare au Gourou). On peut donc écrire, en se basant sur le programme précédent :

toi := moi ;

Mais en faisant StrCpy(toi.nom,"hello world !"), on modifie aussi le contenu de la chaine moi.nom. Par les appels à FreeString, on libère deux fois la même zone et on obtient un Guru Meditation bien mérité.

Les procédures et fonctions

Les procédures et les fonctions sont en fait des regroupements d'instructions, dépendant d'un certain environnement. On distingue deux sortes de procédures (Cf. cet article) : les fonctions, qui renvoient une valeur, et la procédure qui, bizarrement, ne renvoie rien. Vous remarquerez que l'un se définit par rapport à l'autre : une fonction est une procédure qui renvoie une valeur (concept de langages procéduraux comme Pascal) ou une procédure est une fonction qui ne renvoie rien (concept de langages fonctionnels comme le C) : de toute façon, le but est de réduire le nombre d'ins-tructions et permettre une réutilisation du code.

Les procédures (au sens large) sont des petits programme Pascal : elles ont un en-tête, une zone de déclaration, une zone de d'instructions. L'en-tête permet ici de donner les arguments (paramètres) nécessaires à l'appel qui se fera dans une zone d'instruction.

PROCEDURE <nom> ( [ liste de déclarations ] );
FONCTION <nom> ( [ liste de déclarations ] ):< type >

Le nom de la procédure doit être unique. La liste de déclarations est facultative et est de la forme :

[var] <param1> <type 1>; [var] <param2>, <param3>, ... <paramN> <typeX> ; ...

Le mot-clé "VAR" indique que l'argument est passé par référence : toute modification entreprise à l'intérieur de la procédure se répercutera sur la variable réelle passée en argument. Il est optionnel et quand il ne figure pas, cela signifie qu'il y a passage par valeur (une copie de l'argument est affectée au paramètre, donc la variable réelle ne sera pas modifiée).

Vous aurez compris qu'il se crée un lien entre la variable passée en argument (au moment de l'appel) et la variable-paramètre. Ce lien dépend de deux facteurs : le type (les deux variables doivent être du même type) et la position (la place occupée par la variable-argument indique quelle variable-paramètre la représentera dans le corps de la procédure).

Il existe aussi une condition sur les types. Ils doivent tous être nommés ; Pascal interdit, par exemple, d'écrire quelque chose comme ceci dans l'en-tête :

(...; arg2 : record nom : string ; prénom : string ; age : interger ; end ; ... )

Mais pour le passage d'une structure, d'un tableau ou autre, on utilise un nom de type qui a été d'abord défini ; ainsi pour que l'on puisse passer en argument la structure ci-dessus, nous pouvons écrire (en respectant le travail fait dans le chapître précédent) :

... ( ... ; arg2 : personne ; ... )

Pour retourner la valeur d'une fonction, il faut affecter à son nom la-dite valeur (voir exemple ci-après). Une valeur de retour ne peut être qu'un type simple.

Une procédure (ou une fonction) ne peut en appeler une autre que si elle est connue (voir le deuxième article : la portée). Il est évident, suivant la construction, que la procédure appelée ne peut pas disposer des variables de l'appellante : pour qu'une valeur d'une variable soit connue, il faut la passer en paramètre. Bien sûr, les valeurs des variables de l'appellante ne sont pas modifiées (sauf par un passage par référence) quand on "retourne" d'une procédure appelée (après la fin de la fonction appelée, le programme continue à l'instruction suivant l'appel).

La technique qui consiste à déclarer ses variables au tout début du programme et à en faire référence à l'intérieur des procédures et des fonctions n'est pas bonne du tout : on évite la modularité et on crée des tonnes d'effets de bord qui, quand on veut corriger le programme, compliquent le déverminage (débogage).

Le mot-clé "RETURN" permet de sortir imédiatement d'une procédure. Le même effet est réalisé quand on affecte la valeur au nom de la fonction (seulement pour PCQ).

Un appel de fonction peut être fait à l'intérieur même de sa définition (dans la zone d'instruction). Ceci s'appelle la récursivité et permet d'obtenir des procédures (ou des fonctions) plus courtes, mais utilisant beaucoup la pile du microprocesseur. Par ailleurs, on considère que les valeurs des variables locales ne dépendent que du niveau de l'appel. En d'autres termes, on peut considérer un appel récursif comme un appel à une toute autre fonction.

Dans le même ordre d'idées, si vous avez besoin d'une fonction qui fait référence (un appel) à une autre, mais que cette dernière fait référence à la première, vous pouvez déclarer (et non pas définir) une des deux en l'affublant du mot-clé "FORWARD" juste après l'en-tête de la fonction. Vous préciserez ainsi que la fonction à cette signature et que sa définition complète (en-tête, déclarations, et corps) suivront plus bas dans le texte. On désigne cette méthode par "références croisées".

De même, pour des fonctions définies dans un autre fichier source, vous pouvez faire suivre l'en-tête du mot-clé "EXTERNAL", précisant seulement la forme de l'appel sans donner sa définition (déclarations et corps).

Une dernière remarque : il existe des fonctions et procédures prédéfinies (comme WRITE et READ) que vous retrouverez dans la documentation de PCQ.

Pascal

La force du passage par référence réside dans la facilité, evitant le passage par un pointeur (comme en C).

Excellente conclusion, qui me permettra d'aborder les pointeurs dès le prochain article. A bientôt.


[Retour en haut] / [Retour aux articles] [Article précédent] / [Article suivant]