Cours gratuits » Cours informatique » Cours programmation » Cours Oberon » Des projets d'immobilisations pour les anciens terrains de jeux RSA et Oberon de jeu champs

Des projets d'immobilisations pour les anciens terrains de jeux RSA et Oberon de jeu champs

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Des projets d'immobilisations pour les anciens terrains de jeux RSA et Oberon de jeu champs [Eng]

A.1 Vue d'ensemble d'Oberon-2

Le langage de programmation que nous utilisons pour les exemples tout au long du livre est Oberon-2. Oberon-2 a été conçu par Niklaus Wirth, bien connu comme concepteur de nombreux langages de programmation, en particulier Pascal, l'un des prédécesseurs d'Oberon-2. Oberon-2 est un langage de programmation orienté objet et possède des fonctionnalités qui nous permettent d'utiliser les principes importants de l'abstraction, de la dissimulation de données (central pour l'abstraction de données et la conception orientée objet), de la décomposition de probl&eg

rave;mes et de la modularisation. Aussi important pour l'enseignement, Oberon-2 a une syntaxe très simple, et est un petit langage, même si les concepts qu'il implémente sont au cœur de l'ingénierie logicielle avancée.

Nous allons travailler à travers les fonctionnalités de base d'Oberon-2 dans cette annexe, en utilisant des programmes simples pour illustrer chaque nouvelle idée. Les caractéristiques plus complexes qui permettent l'abstraction, la dissimulation de données et la modularisation sont traitées en détail dans le corps du livre. Le traitement d'Oberon-2 est particulièrement adapté à ceux qui ont peu ou pas d'expérience en programmation. Il est suggéré aux débutants de lire cette annexe immédiatement après le chapitre 2.

Nous supposerons que vous avez un ordinateur, un compilateur Oberon-2 et que vous savez taper, compiler et exécuter un programme. Les exemples dans le livre sont implémentés dans POW! Oberon-2 pour Windows, sur un PC. Ceux d'entre vous qui utilisent d'autres compilateurs Oberon-2 peuvent trouver que la procédure ProgMain n'est pas nécessaire, et vous pouvez simplement la laisser hors des exemples.

Nous commençons tout de suite avec le problème de l'affichage d'un message simple sur l'écran du terminal - afficher des messages ou des résultats d'une manière ou d'une autre est très important, car il est inutile d'écrire un programme pour calculer la réponse à la vie, s'il n'y a aucun moyen de trouver le résultat!

MODULE D'abord;

(* Afficher un message important sur le terminal. *) IMPORT Out;

PROCÉDURE ProgMain *;

COMMENCER

Out.Ln;

Out.String ("Bonjour Oberon-2 Monde!");

Out.Ln

END ProgMain;

END D'abord.

Ce programme (lorsqu'il est compilé, lié et exécuté) donne la sortie suivante: Hello Oberon-2 World!

Maintenant nous savons ce que le programme fait, regardons à l'intérieur pour voir comment les fonctionnements internes affichent un message. Chaque ligne du programme a une signification et une utilisation particulières, nous allons donc les examiner tour à tour.

Le programme commence par la ligne MODULE First;

qui indique le nom de notre programme ou module à Premier. Dans Oberon-2, tous les programmes consistent en un ou plusieurs modules; ce programme est assez simple et n'a donc qu'un seul module.

Ensuite, nous avons un morceau de texte entouré de (* et *). Ceci est un commentaire: les commentaires sont utilisés pour décrire ce qu'un programme fait, ou comment il le fait, à un lecteur humain. Ils sont ignorés par le compilateur et ne jouent aucun rôle dans le programme lui-même - ils sont simplement un moyen de transmettre des informations au lecteur. L'utilisation de commentaires est obligatoire pour tous les programmeurs rationnels. Gardez à l'esprit que tout lecteur de votre programme est peu susceptible d'être psychique et peut ne pas être en mesure de déterminer ce que votre programme est destiné à faire uniquement à partir du code. De plus, au fur et à mesure que vous écrivez des programmes pour résoudre des problèmes plus complexes, vous constaterez que vous avez besoin des commentaires autant que n'importe qui d'autre, pour vous rappeler comment fonctionne votre propre code. Oberon-2 permet aux commentaires d'être placés à peu près n'importe quelle position dans un programme, et de s'étendre sur plusieurs lignes. Quelques exemples de code commenté sont donnés ci-dessous.

Out.String ("le total est"); (* Imprimer le message. *) (* Calculer la nouvelle valeur pour le total. *) Total: = total + 1;

Nous sommes également autorisés à imbriquer des commentaires les uns dans les autres. Cela peut être utile si nous voulons placer des parenthèses de commentaire autour d'une section de code pour empêcher son exécution. Par exemple,

nombre: = 5;

(* By-pass lecture du nombre Out.String ("entrer un nombre:"); In.Int (nombre); (* Obtenir le numéro de l'utilisateur. *) *)

carré: = nombre * nombre;

Dans ce fragment de programme, les instructions Out.String et In.Int sont mises en commentaire et ne seront pas exécutées lors de l'exécution du programme.

Maintenant, nous arrivons à une fonctionnalité de Oberon-2 qui est très important pour le génie logiciel - la déclaration d'importation. La ligne

IMPORT Out;

est un exemple d'une instruction d'importation. Oberon-2 est un langage conçu pour permettre aux solutions de problèmes existantes d'aider à résoudre de nouveaux problèmes. Une façon de le faire avec des modules de bibliothèque. Les modules de bibliothèque peuvent être considérés comme une bibliothèque de prêt, à partir de laquelle un programme peut emprunter des solutions de problèmes prêts à l'emploi (généralement appelées procédures) en utilisant des instructions d'importation. Ces solutions sont vraiment des ensembles d'instructions Oberon-2, qui effectuent une tâche ou des tâches spécifiques.

Un programme Oberon-2 typique contiendra des importations de plusieurs modules de bibliothèque. L'instruction import dans First est une requête à la bibliothèque standard Out. La déclaration d'importation doit se trouver en haut du texte du programme, de sorte que les procédures requises sont importées avant toute tentative d'utilisation. Chaque implémentation d'Oberon-2 fournit un ensemble de modules de bibliothèque standard, qui contiennent des procédures pour résoudre certains problèmes très courants, tels que l'importation de données dans un programme, l'impression de résultats et l'exécution de calculs mathématiques. En outre, le programmeur peut créer ses propres bibliothèques de procédures, qui peuvent être réutilisées dans de nombreux programmes différents.

Un seul programme Oberon-2 peut être divisé en plusieurs modules distincts qui sont finalement réunis pour former un seul programme exécutable. Un module a un rôle spécial en tant que module principal du programme et sera exécuté en premier. Comme le module principal lui-même peut contenir plusieurs procédures, il faut désigner la procédure principale, qui sera exécutée en premier. La procédure principale ou première dans un programme s'appelle toujours ProgMain, et la ligne:

PROCÉDURE ProgMain *;

indique son début. Le reste des déclarations, jusqu'à la ligne END ProgMain;

sont le corps de la procédure ProgMain, et ce sont les instructions qui seront exécutées lorsque le module principal est exécuté. Nous regarderons la signification du * plus tard.

Nous avons maintenant atteint la ligne constituée seulement du mot BEGIN. Bien que cela semble une déclaration petite et inconséquente, il est en fait plutôt important, car il marque le début des principaux travaux de la procédure principale ProgMain - la partie qui fait le travail d'imprimer le message en utilisant le procédures importées de la bibliothèque Module Out. Les instructions du corps de la procédure sont exécutées de manière séquentielle lors de l'exécution du programme.

La première instruction à l'intérieur du corps de la procédure, Out.Ln, est une utilisation de la procédure, Ln, importée du module de bibliothèque Out. Ln envoie une commande de retour à la ligne à l'écran du terminal, amenant le curseur à descendre de sa position actuelle au début de la ligne suivante. Notez que nous devons préface chaque utilisation de la procédure Ln par le nom du module de bibliothèque dont elle provient. Cela est vrai pour toutes les procédures empruntées à chaque bibliothèque. Vous pouvez considérer cela comme une perte de frappe, mais la raison en est d'empêcher le compilateur d'être confondu par des conflits de noms. Par exemple, le module Out contient une commande Ln qui envoie une nouvelle ligne au terminal, mais un autre module, Printer say, peut également contenir une commande Ln pour envoyer une nouvelle ligne à une imprimante connectée, et ces deux bibliothèques peuvent être importées dans le même programme . Ces deux procédures Ln seront très différentes les unes des autres, donc nous préfixons le nom du module de la bibliothèque sur le nom de la procédure (séparés par un point) afin que le compilateur sache lequel nous nous référons.

L'instruction suivante utilise la procédure String (également importée de Out). Out.String affiche une chaîne de caractères sur l'écran du terminal, où la chaîne est indiquée en encadrant les caractères à afficher en guillemets doubles ou simples. D'autres exemples d'instructions Out.String valides sont:

Out.String ("Bonjour");

Out.String ("54000 vaisseaux spatiaux noirs"); Out.String ("");

Out.String ('Réponse "Oui" ou "Non"');

Le module First n'utilise que Out.Ln et Out.String pour produire la sortie montrée plus haut.

Examen du programme Tout d'abord, vous devriez voir que toutes les instructions sauf BEGIN, le dernier Out.Ln, END First, et le commentaire, se terminent par un point-virgule. Ceci n'est pas fait simplement pour augmenter la quantité de frappe nécessaire pour écrire un programme, mais parce que les points-virgules sont requis par Oberon-2 pour séparer une instruction ou un bloc de langage d'un autre. Les points-virgules sont donc utilisés comme séparateurs d'instructions. Il est difficile au début de comprendre quand un point-virgule est nécessaire, mais la règle générale est qu'un point-virgule n'est pas nécessaire avant la première déclaration dans une séquence ou après la dernière déclaration dans une séquence. Ainsi, le mot BEGIN et le dernier Out.Ln n'ont pas de point-virgule après eux. Les règles d'Oberon-2 permettent d'insérer un point-virgule supplémentaire après la dernière déclaration d'une séquence; cela a pour effet d'insérer une instruction vide supplémentaire. Essayez d'omettre tour à tour chacun des points-virgules dans le premier module, et de voir quand le compilateur se plaint.

Avoir des séparateurs d'instructions nous permet de placer plusieurs instructions sur une ligne, telles que:

Out.Ln; Out.String ("Bonjour");

Out.Ln; Out.String ("Monde Oberon-2");

Cependant, ceci n'est généralement pas considéré comme un bon style de programmation. En fait, plutôt que de mettre plusieurs déclarations sur une ligne, vous devriez envisager de laisser des lignes vides à des positions stratégiques dans vos programmes, pour les rendre plus faciles à lire et à comprendre.

Vous vous demandez peut-être pourquoi END First et le commentaire n'ont pas de point-virgule à la fin. Le commentaire a ses propres délimiteurs, (* et *); une fois que le compilateur a reconnu le premier (* il ignore tout jusqu'à ce qu'il voie le * correspondant). L'instruction END First est la dernière instruction du corps du module, ainsi que la dernière instruction du module entier. La syntaxe d'Oberon-2 dicte qu'il doit avoir le nom du module après celui-ci, et il doit être terminé par un arrêt complet. Cet arrêt complet indique la fin de tout le module.

Avant d'aller plus loin dans les détails d'Oberon-2, jetons un coup d'œil sur la façon dont le programme First est présenté sur la page. Notez la façon dont certaines lignes sont indentées et certaines lignes vides ont été laissées dans le texte du programme. L'indentation est de mettre en évidence la structure du programme et de le rendre plus facile à lire. Si nous écrivons d'abord sans aucune indentation:

MODULE D'abord;

(* Afficher un message important sur le terminal. *)

IMPORT Out;

PROCÉDURE ProgMain *;

COMMENCER

Out.Ln;

Out.String ("Bonjour Oberon-2 Monde!");

Out.Ln

END ProgMain;

END D'abord.

ce n'est pas si facile à comprendre. Vous devez toujours indenter vos programmes pour afficher leur structure et laisser des lignes vides si nécessaire pour diviser le programme en parties logiques. Essayez d'utiliser les styles d'indentation et de disposition que nous avons utilisés tout au long de ce chapitre, et qui sont donnés en détail dans l'annexe E. Les styles d'indentation ont tendance à varier très peu entre programmeurs (sauf dans la taille de l'indentation). styles très similaires dans d'autres livres sur Oberon-2 (et, en effet, la plupart des autres langages de programmation).

Des exercices

  1. Modifiez le module en premier pour qu'il affiche votre nom sur l'écran.
  2. Ecrire un programme qui imprime votre nom dans un motif de diamant, comme

montré: Claire

Claire Claire

Claire

  1. Trouvez toutes les erreurs de syntaxe dans le programme suivant:

MODULE Test;

(* Imprimer un message de test

PROCÉDURE ProgMain *;

Out.Ln

Out.String ("Test, test);

END ProgMain;

Test END

Une fois que vous pensez que vous avez trouvé toutes les erreurs, tapez le programme exactement comme il est, et utilisez le compilateur Oberon-2 pour vérifier si vous aviez raison. Chaque fois que le compilateur trouve une erreur, corrigez-la et recompilez le programme, jusqu'à ce que vous les ayez tous supprimés.

  1. Lesquelles des chaînes suivantes sont valides:

"abc"

"12 23" 34 "78"

" quarante-deux!

"'bonjour', elle a dit" "s'il vous plaît entrer un nombre 'une nuit sombre et orageuse'

Vous pouvez vérifier si vous avez raison en les remplaçant par la chaîne du programme First original.

  1. Quelle sortie produit le programme suivant?

Message MODULE;

(* programme de sortie de démonstration

PROCÉDURE ProgMain *;

COMMENCER

Out.String ("Oberon-2 est un descendant de Pascal");

FIN; C'est tout *)

END Message.

  1. Écrivez un programme qui imprime vos initiales en lettres majuscules. Utilisez une grille 6 par 6 pour chaque lettre et imprimez 6 cordes. Chaque chaîne devrait être constituée d'une rangée d'astérisques entrecoupés de blancs.

A.2 Mots réservés et syntaxe

Nous n'avons pas encore expliqué pourquoi certains mots de First sont en majuscules, ou pourquoi ils sont arrangés d'une certaine manière dans le programme. Tous les mots majuscules sont des mots réservés qui ont des significations spéciales pour Oberon-2. Par exemple,

Mot réservé Description

MODULE Indique le début d'un module.

BEGIN Indique le début d'un corps de procédure.

END Indique la fin d'un module ou d'une procédure.

IMPORT Utilisé pour emprunter des procédures à partir d'un module de bibliothèque.

COMMENCER, commencer, Commencer

sont pris comme des mots différents dans Oberon-2, bien qu'ils aient tous la même signification en anglais. L'Annexe C donne tous les mots réservés d'Oberon-2, que vous devez éviter d'utiliser comme noms pour les éléments de vos propres programmes.

Tout comme l'anglais a des règles de syntaxe qui nous disent comment construire des phrases correctes, chaque langage de programmation a sa propre syntaxe, qui régit la façon dont nous construisons les énoncés et les programmes. Si nous n'utilisons pas la syntaxe correctement, nos instructions et programmes n'auront aucun sens pour le compilateur, et ne seront donc pas exécutables.

La syntaxe d'Oberon-2 insiste sur un certain classement des pièces dans un module ou un programme. Ainsi, un programme commence toujours par une instruction MODULE, suivie par toutes les IMPORTs requises, puis toutes les déclarations d'éléments de données (que nous verrons plus loin dans cette annexe), la procédure ProgMain s'il s'agit du module principal, toutes les autres procédures , et enfin l'instruction END.

Des exercices

  1. Lesquels des mots suivants sont des mots réservés d'Oberon-2?

ARRÊT fin ELSIF CHAR CH OU

cas Faux VRAI

  1. Pensez-vous que le programme suivant est correct Oberon-2? Si non, pourquoi pas? Comment voulez-vous le modifier pour le corriger? Tapez votre version corrigée et voir si vous avez raison.

MODULE Test;

PROCÉDURE ProgMain *;

IMPORT Out;

COMMENCER

Out.String ("Ceci est un programme de test.")

FIN

END Test.

A.3 Gestion des données

La plupart des programmes ont besoin de données, qui sont manipulées par les instructions du corps du module pour produire des résultats d'une forme ou d'une autre. Ces données se présentent sous de nombreuses formes, depuis les images météo transmises sous la forme d'une séquence de chiffres par un satellite en orbite, jusqu'à un texte tapé par un utilisateur. Oberon-2 insiste pour que nous déclarions des données avant de les utiliser. La déclaration des données signifie que nous indiquons, généralement en haut d'un module ou de la procédure principale, tous les éléments de données que nous allons utiliser dans le module ou le corps de la procédure. Chaque élément de données est déclaré en lui donnant un nom unique auquel il peut être fait référence dans le programme et en indiquant quel type d'élément de données il est. Par exemple, s'il s'agit d'un tableau de nombres réels ou d'un caractère ou d'un entier, etc.

A.3.1 Constantes

Considérons comment nous pourrions écrire un programme qui calcule le nombre d'heures de travail dans une semaine typique, et imprime le résultat. Nous supposerons qu'une journée de travail se déroule de 9 heures à 17 heures, de sorte que le nombre d'heures de travail par jour est de huit heures. Voici une façon d'utiliser les données déclarées dans un tel programme:

MODULE heures;

(* Calculer et afficher le nombre d'heures de travail dans une semaine. *)

IMPORT Out;

PROCÉDURE ProgMain *;

CONST

WorkingDays = 5; (* Jours ouvrables dans la semaine. *)

DailyWorkHours = 8; (* Heures de travail dans la journée. *)

WeeklyWorkHours = Journées de travail * DailyWorkHours;

(* Nombre d'heures de travail par semaine. *)

COMMENCER

Out.String ("Le nombre d'heures de travail dans une semaine est:");

Out.Int (WeeklyWorkHours, 3);

Out.Ln

END ProgMain;

FIN Heures.

Ce programme illustre la forme la plus simple des données dans les constantes Oberon-2. Les constantes sont des éléments de données qui ont une valeur fixe, par exemple, l'entier 42 est une constante. WorkingHours déclare trois constantes, en utilisant le mot réservé CONST, dans la section de déclaration de ProgMain. Chaque élément de données reçoit un nom et ce nom est ensuite utilisé pour faire référence à l'élément de données dans ProgMain. Le programme utilise des procédures importées de Out pour imprimer le nombre d'heures de travail par semaine. La procédure Out.Int affiche un nombre entier sur le terminal: il faut lui donner le nombre entier à afficher (WeeklyWorkHours dans cet exemple) et la largeur de champ minimum (nombre d'espaces) dans lequel imprimer ce nombre (trois espaces dans ce cas) .

Nous aurions pu produire le même résultat que le programme ci-dessus sans utiliser les constantes déclarées:

MODULE Heures2;

(* Calculer et afficher le nombre d'heures de travail

une semaine. *)

IMPORT Out;

PROCÉDURE ProgMain *;

COMMENCER

Out.String ("Le nombre d'heures de travail dans une semaine est:");

Out.Int (40, 3);

Out.Ln

END ProgMain; END Heures2.

En comparant cela à la version précédente, vous devriez convenir que le premier programme est beaucoup plus facile à comprendre. Out.Int (40, 3) pourrait signifier n'importe quoi, mais Out.Int (WeeklyWorkHours, 3) est beaucoup plus clair. Il serait encore mieux d'avoir déclaré la largeur du champ comme une constante, peut-être appelée FieldWidth, de sorte que l'instruction Out.Int ressemblerait à ceci:

Out.Int (WeeklyWorkHours, FieldWidth);

C'est également une bonne raison de choisir des noms significatifs pour les modules, les procédures et les éléments de données.

Les trois constantes utilisées dans WorkingHours sont assez simples: WorkingDays et DailyWorkHours reçoivent respectivement les valeurs 5 et 8; WeeklyWorkHours est une expression constante, car elle ne contient que des constantes et aura la valeur 40. Voici d'autres exemples de constantes Oberon-2 valides et d'expressions constantes:

pi = 3,1416;

FirstLetter = "A";

Salutation = "Bonjour";

TwoPi = 2,0 * pi;

A.3.2 Variables

Déclarer des constantes dans nos programmes est utile, mais ne nous permet pas d'utiliser des éléments de données dont les valeurs peuvent changer. Par exemple, si nous souhaitons écrire un programme à lire dans un caractère à partir du clavier du terminal, nous devons déclarer un élément de données dans lequel stocker le caractère. Nous avons besoin d'un élément de données dont la valeur est autorisée à changer parce que nous ne pouvons pas savoir à l'avance quel caractère l'utilisateur du programme tapera sur le terminal, donc nous ne pouvons pas configurer l'élément de données pour qu'il soit constant.

Les éléments de données dont les valeurs peuvent changer sont appelés variables; ils sont déclarés en utilisant le mot réservé VAR d'Oberon-2. Voici un exemple de la façon dont nous pourrions utiliser une variable dans un programme qui lit un seul caractère du clavier du terminal et l'imprime à nouveau:

MODULE ReadChar;

(* Lire le caractère du clavier, et réécrire. *)

IMPORT In, Out; VAR

ch: CHAR; (* la variable pour lire le caractère dans *)

PROCÉDURE ProgMain *;

COMMENCER

Out.String ("Tapez un caractère et appuyez sur Retour ..."); In.Char (ch);

Out.Ln;

Out.String ("Vous avez tapé le caractère ..");

Out.Char (ch);

Out.Ln

END ProgMain;

END ReadChar.

Ce programme contient une déclaration d'un élément de données variable appelé ch. La valeur de ch devient le caractère tapé sur le clavier, qui est lu par la procédure Read (Read lit un seul caractère, Out.Char affiche un seul caractère). Le CHAR après ch déclare quelle classe d'objets de données ch appartient à - la classe d'un objet de données est plus généralement appelée son type. Type CHAR signifie que ch est un caractère (plutôt qu'un nombre entier ou un nombre réel, etc.) et peut donc prendre la valeur de n'importe quel caractère valide, tel que "!" ou "g". La plupart des implémentations d'Oberon-2 utilisent un jeu de caractères appelé le jeu de caractères ASCII. Ils sont définis dans l'annexe B. Le jeu de caractères ASCII inclut tous les caractères que vous attendez (lettres majuscules et minuscules, chiffres, ponctuation), et quelques caractères inhabituels.

L'autre chose à noter à propos de ce programme est que nous importons d'une autre bibliothèque, appelée In, qui contient les procédures de lecture des éléments de données dans nos programmes. Dans ce cas, nous utilisons la procédure de lecture des caractères, In.Char.

Le type d'un élément de données est essentiel car il nous indique deux choses très importantes à propos de l'élément:

  • La plage de valeurs que peut prendre l'élément de données. Par exemple, si nous utilisons le jeu de caractères ASCII, il y a 128 caractères possibles pour un élément de données de type CHAR.
  • Les opérations qui peuvent être effectuées sur ou avec l'élément de données. Par exemple, l'addition et la soustraction sont des opérations valides pour les nombres entiers, mais pas pour les caractères.

Oberon-2 nous fournit des classes ou des types prêts à l'emploi pour nos éléments de données dont la gamme de valeurs et les opérations sont déjà définies. Ces types prêts à l'emploi sont les suivants:

Nom du type Signification

Caractères CHAR, par exemple, a,!, F.

INTEGER Numéros entiers, par exemple, 0, 56, 23100, -4567

REAL nombres réels, par exemple, 2.13, 0.0, -32.009, 2.3E2.


50