Introduction A1-1 - COURS du 04 octobre Etape de la création d un programme

(1)

COURS du 04 octobre 2004

Etape de la création d’un programme

1 l’énoncé : description en français, utilisation du langage mathématique 2 l’algorithme : transcription en pseudo code

3 le programme : transcription en ADA

site du prof : http://perso.wanadoo.fr/robert.vandaele/

remarques :

-- => sert au commentaire (ne pas mettre d’accent)

*.ADB pour le body

*.ADS pour la spécification with ada.text_io ;

use ada.text_io;

Ces 2 expressions servent pour tous les programmes (entrées/sortis) Caractère ‘A’, utilisation des apostrophes

Chaîne « Algorithmique », utilisation des guillemets

Voir ADA01_01.adb

Introduction

(2)

Voir Poly « Les bases de la programmation structurée »

I Syntaxe

A Vocabulaire

Codage : passer d’un algorithme à un programme

Syntaxe : ensemble des règles de construction des mots du langage (orthographe) Sémantique : sens des mots et des associations de mots (grammaire)

B Langage impératif

Ex : pascal, algo Caractéristique :

- Structure de blocs (begin…end)

- Gestion de la communication entre blocs (paramètres) - Construire ses propres types de données

ADA est un langage impératif, avec en plus :

- la généricité (modèle qui suit le type de données) - bon mécanisme d’exception

- outils de compilation séparés

- moyen de programmation parallèle (tâches, rdv)

C langage fonctionnel

Langage logique : prolog

Langage objet :c++, ADA95, java (langage non compilé, nécessite une mach virtuelle) Langage fonctionnel applicatif LISP

la propriété, c’est la description de la fonction

Recherche du chemin min entre A et B

Etape du langage impératif :algorithme, recherche opérationnelle, algorithme de Little

Etape du langage fonctionnel : il recherche tous les chemins possibles et détermine le + court par rapport à une valeur

Chapitre 2 : Programmation

A

C D

B

E F

(3)

II Sémantique

II - 1 Les caractères

Caractères

Ils sont définis au niveau du langage, il existe un jeu de caractères de 256 positions en liaison avec le système d’exploitation

Chaîne de caractères

C’est une suite de caractères, en ADA elles ont une longueur fixe Délimiteurs

‘ ‘ , c’est un caractère

“ ” , c’est une chaîne de caractères exemple : ‘A’ ; ‘a ‘ ; ‘O’

“ ABDEF ” a une longueur de 6 Opération sur les chaînes

Concaténation : « abc » & « def » donne « abcdef »

II - 2 Commentaires et libellés

Commentaire

Phrase dans le texte du programme qui favorise la lisibilité de celui ci sans y appartenir En ADA, le commentaire commence par 2 tirets « -- commentaire »

Libellé

Phrase qui fait partie du programme, exemple : un message que l’on visualise

II - 3 Grammaire

Syntaxe : règles de construction des mots

Règles lexicales : ce qui appartient au langage (jeu de caractères, mots réservés) Règles syntaxiques : ce sont les constructions des mots

Exemple : variable (I, n1, nombre)

Pas valide : put (mot réservé), un nombre car 1 variable commence par une lettre, 2 tirets (commentaire)

Le compilateur possède

Un analyseur syntaxique (lexical et sémantique) Un lien interne

Un lien externe (EDL : Editeur De Lien)

(4)

II - 4 Les expressions

Expressions arithmétiques

Description du BNF : Bacchus Norm Form. Bacchus a réalisé au 9ème siècle une description mathématique des langages informatiques

Exp : expression

::= « se définit comme »

| « ou »

C’est une écriture récursive : à l’intérieur de la définition, je défini l’expression

« * » opérateur binaire (2^ème argument 12*34)

« + » opérateur binaire

« -°» opérateur binaire

opérateur unaire : n’affecte qu’une fois l’expression, ex : -30 Il existe 3 types d’écriture pour l’opération binaire :

Infixé a+b

Préfixe +ab

Postfixé ab+

Expression sémantiques

Contrôle sur le nombre d’arguments N1, N2, N3 de type entier

-N1-N2*N3

1^ère opération : la multiplication 2^ème opération sur N1

3^ème opération entre N1 et le reste

(5)

III Exemples de programmation

Ordre de priorité des calculs :

** exposant

* / multiplication / division + - addition / soustraction

Exemple :

Procedure essai_tableau is nb_elem:integer;

begin

Put("rentrer le nb d'element du tableau");

get(nb_elen);

declare

-- declaration du tableau à nb_elem éléments begin

-- remplissage du tableau end;

end essai_tableau;

Put( I, width=>4) ; ou Put(I,4) ; : I de longueur 4, par défaut c’est 11 caractères 16#1FE# : nombre hexadécimal

1*16 puis 2 + 15*16 puis 1 + 14*16 puis 0 soit 510

510 16

30 31 16

14 15 1

E F 1

(6)

I Historique

I - 1 Classification des langages

L1G langage de 1^ère génération, langage machine L2G assembleur

L3G fortran, cobol, c, c++, ADA…

L4G langage orienté utilisateur final (natural, SQL, windev)

L5G intégration du système d’exploitation et du langage (voir VM + Java)

I - 2 Les débuts de ADA

Suite à un échec d’une fusée de la NASA programmée en fortran, le DOD (Department of Defense) lance un concours pour créer un langage fiable avec un cahier des charges (1975)

1979 le langage retenu est l’ADA, développé par une équipe de CII – HB user (Cie Intérêt Informatique, français)

1980 l’ADA est normalisé par l’ANSII 1983 MRF manuel de référence 1987 ADA est reconnu par ISO

1995 ADA 9X ou ADA95, graphisme, programme orienté objet

II Concepts du langage ADA

Lisibilité afin de faciliter la maintenance

Fiabilité contrôle très serré, langage typé complètement (on doit tout déclarer)

Modularité on peut découper le programme en module, procédure, fonction, package (compilation séparée)

Réutilisabilité généricité, les modules sont réutilisables tel que

Structure de données abstraites on définit un type de données et les opérations sur ce type Traitements des exceptions sert à faire de la programmation sans panne (PSP)

Utilisation de tâches parallèles tâches, RDV

III La source de l’exécutable

Compile ne fait que la compilation => fichier *.o (objet)

Build compile + link edit, compilation et édition des liens => programme exécutable Exécution fenêtre DOS pour l’exécution

Chapitre 3 : Introduction à ADA

(7)

IV Structure d’un programme

Exemple : En ADA With… ; Use… ;

Procedure prog01 is -- partie déclarative begin

-- corps du programme 01 end prog01 ;

Représentation :

Voir ADA03_01 ;adb

Attention à la définition d’un bloc à l’intérieur du programme (declare, begin, end) Intérêt de la création d’un bloc :

- Permet des calculs intermédiaires importants

gestion dynamique de la mémoire, en unix et à partir de windows XP

- Sert à la gestion dynamique d’un tableau dans le cas d’une construction de tableau de taille saisie au clavier

V Les objets du langage

La fin d’un bloc fait disparaître les objets du bloc ainsi que leurs résultats

V - 1 Le jeu de caractères

Ce sont les éléments lexicaux : Lettres (min, maj) Chiffres

Caractère espace Caractères spéciaux :

Simples : " délimiteur de chaînes de caractères

# délimiteur de littéraux basés

& délimiteur de concaténation de chaînes

‘ délimiteur de caractères

( ) délimiteur d’expression arithmétique

* délimiteur de multiplication

, délimiteur de variables de même type (déclaration par exemple) - délimiteur de soustraction

. délimiteur de décimales / délimiteur de division

: délimiteur de variable, type de variables

; délimiteur d’instruction

> = < délimiteur de comparaison

(8)

_ c’est un espace

| c’est le ou

composés : => donne une valeur à une structure interne ex : put(I, width=>4) .. valeur initiale, finale d’une boucle. Définit un intervalle

** puissance, exponentiation := instruction d’affectation /= différent

>= ou <= instruction de comparaison

« » étiquette

<> boîte, tableau non contraint

V - 2 Les identificateurs

Ce sont des assemblages de lettres, chiffres et caractères spéciaux servant à nommer une variable, un type, un sous algorithme (procédure, fonction), un package (procédure contenant variable, type, procédure, fonction), un bloc, une boucle

Règles de programmation : ça commence par une lettre, ne se termine pas par un tiret bas ni par 2 tirets bas. Cela ne peut pas être à cheval sur 2 lignes et ne doit pas être un mot réservé (words reserved dans le manuel de référence).

Abort : abandon d’une tâche Abs : valeur absolue

Access : type d’accès, pointeur

V - 3 Les commentaires

Ils se placent après 2 tirets bas et peuvent se mettre après une instruction

V - 4 Les littéraux, les notions de type

Un type en ADA est caractérisé par un ensemble de valeurs et un ensemble d’opérations sur ces valeurs

1 Les Littéraux caractères

Un caractère unique entre apostrophe ‘a’. C’est définit dans le package STANDARD, il n’est pas à référencer (c’est celui par défaut)

Utilisation de la table ASCII (256 symbôles)

Package ASCII : permet l’accès aux caractères non graphiques, ex beep ASCII.BEL 2 Les littéraux chaînes

C’est une suite de caractères entre guillemets, " Programmation ". Une chaîne peut être vide " ", elle peut se concaténer avec &

(9)

3 Les littéraux numériques

Ils représentent des nombres entiers ou réels Notation : 125000 ou 125_000 ou 125^E3

Entier prédéfini (type) : integer, construit dans le package standard Pour les nombres réels : 3.141592 ou 3.14_159_2 ou 31.41592^E-1 Réel prédéfini (type) : float

4 Les littéraux basés

2#1111_1111# correspond à 255 en décimal

VI Les expressions

VI - 1 Les opérateurs

Logique and or xor

Relationnel /= < > <= >=

Additif unaire, binaire + - &

Multiplicatif * / rem (reste division euclydienne) mod (modulo, ex 5mod4 c’est 5 tours + position soit 1)

Prioritaire ** abs not

Ordre de priorité ADA : opérateur prioritaire vers opérateur logique

VI - 2 Les opérations

ADA est un langage complètement typé I : integer :=2 ;

J : integer:=5;

K:integer;

R:float:=3.5;

Y:float:=4.7;

Z:float;

Partie instruction:

K:=I*J; -- K contient 10

Z:=R+Y; -- Z contient 8.2

Z=I+Y ; -- non permis

Z :=float(I+J) ; -- conversion de type, opérateur de cast Ou

Z :=float(I) + float(J) ;

(10)

VI - 3 Les opérateurs de comparaison

"ABCDEF" < "abxa"

Cette relation est vraie (booléen true ou false)

VI - 4 Test d’appartenance

‘a’ not in ‘b’..’z’ -- vrai j:=10

j in 1..40 -- vrai

if j in 1..40 then

put_line(“J est contenu dans l’intervalle") ; else

put_line("J est en dehors de l’intervalle") ; end if ;

VII Les instructions

Type de données Déclaration ADA

Entier Integer

Réel Float

Logique Boolean

Caractère Character

Chaîne String

VII - 1 Structure générale

Format BNF

Instruction ::={étiquette} instruction simple | {étiquette} instruction composée

instruction simple ::= instruction d’affectation | appel de procédure nom de la procédure instruction exit permet de sortir d’une structure

instruction nulle null en ADA

instruction retour return, set à la fin d’une fonction instruction goto

instruction raise exception, permet de laisser passer une instruction instruction delay attendre n millisecondes avant la prochaine instruction instruction abort abandon de tâche

instruction d’appel d’entrée entry instruction composée ::=

instruction de bloc begin, end instruction de boucle for, tant que instruction si, si alors sinon, si alors sinon si instruction cas case, end case instruction accept les tâches, select les tâches instruction étiquette ::= « nom_etiquette » instruction nulle ::= null

(11)

VII - 2 Instruction d’entrée, sortie simple

Ces instructions font appel à des packages, plus précisément à des procédures dans les packages. Il y a toujours ADA.text_io

Put : pour les caractères et les chaînes (put_line existe aussi) Get : pour les caractères et les chaînes (get_line existe aussi)

Put va de la mémoire vers l’organe de sortie Get va de l’organe de sortie vers la mémoire

VII - 3 Instruction d’affectation

Syntaxe : nom de variable ::= expression

Le nom à gauche ne doit pas être déclaré comme constante TVA1 : float :=19.6 ;

TVA1 :=TVA1+1.0; -- pas d’erreur TVA := constant float :=19.6 ;

Le type de nom_variable est du même type qu’expression

VII - 4 Instruction si

If condition then Suite_instr1 Elsif condition then Suite_instr2 Else

Suite_instr3 End if ;

Le elsif est facultative, il peut se reproduire n fois

Le else est facultatif, il ne se répète qu’une fois et à la fin If then end if ;

If then else end if;

If then elsif then elsif then else end if;

VII - 5 Instruction cas

Case expression is

When cas1 => traitement1;

When cas2 => traitement2;

. . .

When casN => traitementN;

When others => traitement autre ; End case ;

(12)

Exemple:

Mois:integer; (1..12) Nb_jour : integer ; (0..31)

Annee_bissextile : integer ; (0..1) Case mois is

When 1 => nb_jour :=31 ;

When 2 => nb_jour :=28+ annee_bissextile ; When 3 => nb_jour :=31 ;

. . .

When 12 => nb_jour :=31 ;

When others => put(“erreur sur le mois”);

End case;

Autre solution Case mois is

When 1|3|5|7|8|10|12 =>nb_jour:=31;

When 4|6|9|11=>nb_jour:=30;

When 2 => nb_jour:=28 + annee_bissextile;

When others End case;

Remarques:

Après le when on a une expression, une suite d’expression séparée par | ou un intervalle 1..5 La condition doit être de type discret (entier, type énuméré ou type booléen)

La clause other est obligatoire si tous les cas ne sont pas énumérés

VII - 6 Les boucles

Boucle Pour

Utilisation dans un intervalle défini

Syntaxe for var_boucle in (reverse) intervalle loop instruction_boucle

End loop ;

Reverse permet d’aller dans l’ordre décroissant Boucle tant que

Utilisation tant que la condition n’est pas réalisée Syntaxe while condition loop

Instruction boucle End loop ;

Nb : il est nécessaire de faire varier la condition dans instruction boucle

(13)

VIII Exemples de programme

VIII - 1 Les littéraux

Voir ADA03_02

VIII - 2 Les étiquettes

Voir ADA03_03

(14)

I Les types prédéfinis entier – réel

Utilisation du « put image » : ne nécessite pas d’instanciation Syntaxe : put(type’image(variable)) ;

Voir ADA04_01

Remarque : le put image cadre à gauche car il considère que c’est une chaîne de caractères

I - 1 Le type entier

Il est défini dans le standard avec integer, il est borné (first et last) Déclaration :

I : integer ; K :integer :=38 ;

On peut aussi écrire K :=38 ; mais ce n’est pas conseillé Corps :

Put(I) ;

Il faut initialiser la variable Déclaration d’une constante : L :constant integer :=10 ; Ou L :constant :=10 ; Déclaration multiple : M,N :integer ;

M,N :integer:=0 ;

Types d’entiers définis par G-NAT : Short short integer 8 bits signés Short integer 16 bits signés

Integer 32 bits signés

Long integer 32 bits signés

Long long integer 64 bits signés

Voir ADA04_02

Chapitre 4 : Les types prédéfinis,

les entrées sorties correspondantes

(15)

I - 2 Les types réels

Déclaration : R :float ; S,T : float ; U: float :=1.0 ;

PI : constant float := 3.1415926536 Types:

Short float 32 bits |EEE short (norme) Float 32 bits |EEE short (norme) Long float 64 bits |EEE short (norme) Long long float 64 bits |EEE short (norme)

Voir ADA04_03

II Les entrées sorties correspondantes

II - 1 Les entrées sorties sans instanciations

Utilisation de ADA.integer_text_io et de ADA.float_text_io Voir ADA04_04

II - 2 L’instanciation

2 instanciations possibles : interne

Voir ADA04_05 ou externe (package)

COURS du 08 novembre 2004 Package Iio.ads

-- création

with ada.text_io ;

package Iio is new ada.text_io.integer_io(integer);

ou

package Iio is new integer_io(integer);

Package Fio.ads -- création

with ada.text_io ;

package Fio is new float_io(float);

Package Bio.ads -- création

with ada.text_io ;

package Bio is new enumeration_io(boolean)

Voir ADA04_06

(16)

Conseil d’utilisation

Pour les entiers et les réels: package du compilateur ou l’instanciation interne

Pour les booléens : instanciation interne ou externe ( en cas d’envoi, joindre le Bio avec le programme)

Pour les types construits ou particuliers : instanciation interne (long long integer, type couleur, etc…)

III Les entiers basés : exemples

Les entiers basés positifs

Voir ADA04_07 Les entiers basés négatifs

Voir ADA04_08 Nb : page 11

Set_col(40) signifie : tabulation jusqu’à la colonne 40 de la ligne ou de la ligne suivante si la position actuelle est supérieure à 40

Page 12

Dans l’exécution, on préfère la base avec des #. Pour les négatifs, on préfère le « - » devant la base

(17)

I Classification des types

Types signés (+ et -)

Types modulaires

Types entiers Types énumérés (boolean) Types discrets

Types flottants

Types binaires Types décimaux Types points fixés

Types réels Types scalaires

II Les déclarations

I : integer ; I prends 4 octets

J: float:1.0; J prends 10 octets : 8 pour la mantisse et 2 pour l’exposant Voir ADA05_01

Pour les entiers Integer’attribut

First 1^ère valeur de l’ensemble des nombres entiers Last dernière valeur de l’ensemble des nombres entiers

Image(I) pas d’instanciation, donne une chaîne de caractères

III Blocs et portées

Voir ADA05_02

A la fin d’un bloc, contenant et contenu ont disparu, c’est le concept de portée de bloc. La portée d’une variable est le bloc de déclaration.

IV Les types

Un type est caractérisé par 2 éléments : - une ensemble de valeurs

- un ensemble d’opérations sur ces valeurs entier : valeur de integer’first à integer’last

opération + - * /

Chapitre 5 : Les types scalaires

(18)

énumérés : type couleur is ( rouge, orange, vert) ;

0 1 2

opérations sous forme d’attributs

couleur’val(0)->rouge (ADA force la casse en majuscule) couleur’pos(vert)->2

déclaration

C : couleur ; C :=ROUGE ;

C1 :constant couleur :=ROUGE ; Voir ADA05_03 Voir ADA05_04

V Les sous types

Voir le LRM : Language Reference Manuel Un sous type est caractérisé par :

- un sous ensemble de valeur du type - les opérations du type

Le sous ensemble de valeurs est donné à partir d’une contrainte Sous type prédéfini : natural de 0 à integer’last

Dans standard :

Sub_type natural is integer range 0..integer’last ; -- 0..integer’last est la contrainte

remarque :

N1,N2,N3 :natural ; N1 :=5 ;

N2 :=10 ; N3 :=N1-N2 ;

Il est possible que l’exécution donne une erreur Utilisation des sous types :

Avantages augmenter l’efficacité à l’exécution

On peut empêcher des valeurs interdites dans un sous type (ex : nombre de mois)

Inconvénient effet de bord possible( débordement hors du cadre) Voir ADA05_05

Voir ADA05_06

(19)

VI Les types discrets

VI - 1 Les types entiers

Types entiers signés : c’est le type prédéfini integer Les opérations

Affectation :=

Test égalité/inégalité = /=

Test d’ordre > < >= <=

Unaire + - abs

Arithmétique + - * / mod rem **

Dans standard :

Sub_type natural is integer range 0..integer’last ; Sub_type positive is integer range 1..integer’last ; Attributs

Integer’first->-2 147 … Integer’last-> +2 147 …

Integer’image(123)-> 123 (entier/chaîne) Integer’pred(5)->4

Integer’succ(5)->6

Integer’pos(5)->retourne le rang de la valeur Voir ADA05_07

Types modulaires : notion mathématique de congruence, sert pour les calculs cycliques Voir ADA05_08

Utilisation dans la gestion de la mémoire tampon et buffer

VI - 2 Les types énumératifs

Type booléen

Dans standard, on a type boolean is(false,true) ; Operation and, o, not, xor (ou exclusif) Priorité Not

And, or, xor Type character

COURS du 29 novembre 2004 Il est défini dans le package ASCII, package fils de text_io

Put(character’pos(A))->65 donne la position de A dans le code ASCII De A vers a, il faut additionner 32

Put(character’val (65))->A donne le caractère à partir de la position dans le code ASCII De 0 à 31, ce sont des valeurs de contrôle, à ne pas utiliser

Voir ADA0509

(20)

Type contraint (utilisateurs)

type couleur is ( rouge, orange, vert) ;

position 0 1 2

put(couleur’pos(1))->orange il faut instancier le type couleur

with couleur_io is new enumeration (couleur);

use couleur_io;

type fruit is (pomme, orange, poire) ;

Ici, il y a surcharge sur « orange » qui est présent dans fruit et couleur

On doit qualifier la variable : couleur’(orange) --c’est le seul cas d’ADA où il y a des parenthèses après une apostrophe

Notion de sous type :

type jour is (lun, mar, …dim) ;

sub_type jour_ouvrable is jour range lun..ven ; Attributs

Couleur’first->rouge Couleur’last->vert

Couleur’succ(rouge) ->orange Couleur’pred(vert)->orange

Couleur’succ(vert)->constraint error Couleur’pred(rouge)-> constraint error Jou’pos(mer)->2

Couleur’pos(rouge)->0 Couleur’val(1)->orange

VII Les types réels

VII - 1 Les types flottants

Il est à point flottant, ou à virgule flottante Le type prédéfini, c’est float

Voir ADA05_10 (page 14)

‘large : donne le modèle le plus grand associé au type float

‘epsilon : donne la plus petite valeur significative de la machine On peut modifier la précision

type mes_reels is digit 12.

type mes_reels is digit 10 range –1.0 .. 1.0 ;

(21)

VII - 2 Les types points fixés

VII 2 - 1 Les types binaires

C’est réservé aux applications scientifiques ou particulières VII 2 - 2 Les types décimaux

C’est réservé aux applications comptables Exemple :

Type argent is delta 0.01 digit 12 ;

-- 2 chiffres après la virgule et 10 chiffres avant

Voir ADA05_11

(22)

Composé de types simples répétitifs (tableau, vecteur) Ou

Composé d’un assemblage de types simples (article) Vecteur : tableau à 1 dimension

Tableau : tableau à 2 dimensions au moins Article : nom, chiffre, adresse

Tableaux d’articles : on fait un tableau de tous les articles

I Les tableaux

Présentation Tableau T

Indice 1 2 3 4 5

T(1) = vecteur TAB-> 3 L, 4 C

1 2 3 4

1

2 X

3

Vue logique X en TAB(2,3)

Matrice carrée :

Tableau à 3 dimensions : ligne, colonne, profondeur Déclaration

A : array integer range (1..6) of float

« array » pour indiquer un tableau ou vecteur

« integer range (1..6) » pour indiquer 1 dimension avec un indice en entier de 1 à 6

« of float » pour indiquer que les composants sont des réels

A 1 2 3 4 5 6

Ecriture abrégée : A : array (1..6) of float

Chapitre 7 : Types composés

(23)

Remise à zéro du tableau Chargement par boucle For i in 1..6 loop

A(i) := 0.0;

End loop

Chargement par agrégat A:=(0.0,0.0,0.0,0.0,0.0,0.0);

Voir ADA07_01

Tableau à 2 dimensions

AA : array (integer range 0..2, integer range 0..3) of float;

Il y a 3 lignes *4 colonnes, soit 12 composants Ecriture abrégée:

AA : array (0..2,0..3) of float ; Remise à zéro du tableau For i in0..2 loop

For j in 0..3 loop AA(i,j) := 0.0;

End loop;

ou

AA: array (0..2, 0..3) of float:= [(0.0,0.0,00,0.0), (0.0,0.0,00,0.0), (0.0,0.0,00,0.0)],

Voir ADA07_02

COURS du 06 décembre 2004 Type jour is (lun,mar….dim) ;

Heures_ouvrees : array (jour) of float ; Sub_type jour_ouv is jour range lun..ven ; D :jour_ouv ;

For j in jour_ouv loop

Heures_ouvrees (j) :=7.0 ; End loop ;

Heures_ouvrees(sam) :=0.0 Heures_ouvrees(dim) :=0.0 Attributs :

Heures_ouvrees’first->lun Heures_ouvrees’last->dim Heures_ouvrees’length->7 Heures_ouvrees’range->lun..dim

Ou Heures_ouvrees’first .. Heures_ouvrees’last

(24)

Attributs pour tableaux a au moins 2 dimensions : AA’first(1)->0

AA’first(2)->0 AA’last(1)->2 AA’last(2)->3 AA’length(1)->3 AA’length(2)->4 AA’range(1)->0..2 AA’range(2)->0..3

Il vaut mieux utiliser les attributs que les valeurs d’indices Nb : représentation colonne/ligne dans le langage fortran

Voir ADA07_03

II Les types tableaux

A, AA, … : type anonyme

2 exceptions en ADA pour les données sans type : tableaux et tâches Ce sont des entités non typées

Si on écrit

C : array (1..4) of float ; D : array (1..4) of float ; D:=C;

On obtient une erreur de compilation “type mismatch”

Concept de tableaux non contrains

Type vecteur is array (integer range <>) of float ;

On définit ainsi un tableau à 1 dimension de réels dont on définira les dimensions plus tard V : vecteur (1..6) ;

R : vecteur (1..5) ; V := (…..) ; R := (…..) ;

V :=R ; -- est valide

Voir ADA07_04 Voir ADA07_05

(25)

III Caractères et chaînes

Type chiffre_romain is (‘I’,’V’,’X’,’L’,’C’,’D’,’M’) ; Chiffre : chiffre_romain :=’D’

Chiffre<’L’->false chiffre_romain’first->’I’

chiffre_romain’last->’M’

chiffre_romain’succ(‘X’)->’L’

chiffre_romain’pos(‘M’)->6

Type character, défini dans standard

type character is (null,….,’A’,’B’,’C’,…’a’,’b’,’c’,….del);

il existe des caractères non éditables nul ASCII.NUL

bel ASCII.BEL Type chaînes

Type string is array(positive range <>) of character;

S:string(1..7;

S:=”ABCDEF”;

Recherche de la position D:

For I in s’range loop If s(i)=’D’ then

Put(‘Le D est en position”);

Put(i) ; End if ; End loop ;

Ch:string:=(‘o’,’n’); est équivalent à Ch:string:=(‘on’);

:Maj et min sont différenciées

Les chaînes de caractères sont comme des tableaux

(26)

IV Les articles

description

Un article est composé de types différents. Il n’y a pas d’article anonyme, tous les articles auront un nom.

Type nom_mois is (jan, fev, mar…dec) ; Type date is record

Jour : integer range 1..31 ; Mois : nom_mois ;

Annee : integer ; End record ;

Chargement : Par agrégat

D :date :=(31,dec,2004) ; Ou par notation pointée D :date ;

D.jour :=31 ; D.mois := dec ; D.annee :=2004 ; Ou par nom

D :=(annee=>2004, mois=>dec, jour=>31) ; Type vide is record

Null ; End record ;

Voir ADA07_06

(27)

COURS du 13 décembre 2004

Voir poly

I Les vecteurs

Si vecteur non trié : on veut trouver un élément dans un vecteur et dire qu’on l’a trouvé 3types de données : entrée, sortie et local (interne à la procédure)

Si vecteur trié : la recherche s’arrête si la valeur suivante est supérieure à la valeur cherchée

II Recherche dichotomique

Le vecteur doit être trié

Tri des éléments d’un vecteur : tri à bulle

1 7 9 8 2 4

si le suivant est inférieur alors on inverse

fin 1^ertour 1 7 8 2 4 9 9 est arrivé à la fin

fin 2^èmetour 1 7 2 4 8 8 est arrivé à la fin

fin 3^ème tour 1 2 4 7 7 est arrivé à la fin

fin 4^ème tour 1 2 4 4 est arrivé à la fin

fin 5^ème tour 1 2 2 est arrivé à la fin

résultat 1 2 4 7 8 9

Voir ADA08_01

Chapitre 8 : Algorithme des tableaux

(28)

Introduction

2 thèmes fonctions procédures

Les fonctions ont 1 ou plusieurs paramètres en entrée et un résultat en sortie

Les procédures ont 1 ou plusieurs paramètres en entrée (3 types : entrée, sortie et entrée/sortie) et plusieurs résultats en sortie

Elle s’exécute comme une instruction

I Les fonctions

Il existe des fonctions fournies par le compilateur Ex : pred, succ, sqrt

Une fonction commence par un mot clef « function », elle est suivie par l’identificateur (nom) et se termine par « return »

Il y a 2 parties :

La spécification .ads

Le corps (déclaration de la fonction) .adb Voir ADA09_01

COURS du 03 janvier 2005 Voir ADA09_02

Fonction factoriel

N ! = N * (N-1) * (N-2) * …*1

Voir ADA09_03 Fonction factorielle récursive : la fonction s’appelle elle-même Ex :

5 ! = 5 * fact(4)

4 ! = 4 * fact(3), etc….

Voir ADA09_04 Voir ADA09_05 Voir ADA09_06

Chapitre 9 : Les sous algorithmes

(29)

II Les opérateurs

L’identificateur d’une fonction peut être :

And or xor

= < > <= >=

+ - & abs not

* / mod rem **

Cette liste est exhaustive

Le nom est alors entre guillemets Ex : « + »

Voir ADA09_07 Mise en évidence du phénomène de « surcharge »

ADA recherche la fonction suivant les opérateurs (entier ou vecteur) et l’applique

III Les procédures

Une procédure ne fournit pas de résultats. On les retrouve en paramètres de sortie.

Une procédure s’exécute comme une instruction Mot clef : procedure

Nom : identificateur

Mots réservés interdits Pas de résultat

3 modes de paramètres IN lecture

OUT sortie, écriture IN OUT lecture, écriture

IV Paramètres nommés et paramètres par défaut

Voir ADA09_10

COURS du 10 janvier 2005 Si on ne renseigne pas un élément, il prend la valeur par défaut

Voir ADA09_11

Permet de voir comment gérer un élément qui se trouve dans 2 types différents, l’ambiguïté est levée en qualifiant l’élément par son type

(30)

I Les paquetages

Rappel : le mécanisme de pile

2 mots clefs : empiler(x1)->mettre x1 dans le fond de la pile empiler (x2)->FILO first in last out

dépiler N:=depiler N<-x2 M:=depiler

Csq: la pile se vide M<-x1

Pile :

X2

X1 X1

Application système HEAP pile système

STACK pile

RPP : retour programme principal

Prog1 SP1 SP2

X

RPP Retour SP1

RETURN RETURN

Dépile, retour SP1 Dépile, RPP

Retour SP1

RPP RPP

7 appels successifs

Chapitre 10 : La modularité, notion de package

(31)

Autre application : expression arithmétique (a+b)*(c+d)

ECP Expression complètement parenthèsée Exemple de pile :

Max : constant integer :=100 ; P : array (1..max) of integer ; Haut : integer range 0..max ; Procedure empiler (x :integer) is Begin

Haut :=haut+1 ; P(haut) :=X ; End empiler ;

Function depiler return integer is Begin

Haut:=haut-1;

Return p((haut+1);

End depiler;

Haut:=0;

N1,N2:integer;

Hauteur max de 100

3 2 Pile P

Begin

Empiler(2) haut-1

Empiler(3) haut-2

N1:=depiler n1<-3, haut-1

N2:=depiler n2<-2, haut-0 !pile vide haut=0

Inconvénient : dans un langage à structure de blocs, on a accès à empiler, depiler mais aussi à p, haut

Si, dans le programme, on met haut à 0 alors on perd la pile Il convient alors d’utiliser un package qui contourne ce problème

Voir ADA10_01 ADS partie visible

Description empiler/depiler ADB partie non visible

(32)

II Unité de bibliothèque

ADA->compilation séparée, spécification en ads et appel avec le with en adb Le build sert à l’exécution, il compile et édite un lien (EDL)

3 fichiers : package.ads package.adb source.adb

Mécanisme de la compilation séparée Mécanisme du haut vers le bas (topdown) Debut

Cas1 Cas 1.1 Cas 1.1.1

C’est une progression linéaire descendante ADA génère l’ordre de dépendance

Le cas 1.1.1 dépend du cas 1.1 qui dépend du cas 1 Mécanisme du bas vers le haut (bottomtop)

Pour les applications systèmes, ex : les pilotes

III Le surnommage

Declare

Procedure pempiler (x :integer) renames Pa_pile.empiler;

Function pdepiler return integer renames Pa_pile.depiler;

Begin

Pempiler(m);

N:=pdepiler;

Cela permet de changer des noms de procédures, fonctions si double emploi

(33)

I La saisie d’une chaîne de caractères

ADA.text_io

Le package ADA.text_io donne un certain nombre de clauses pour faire de l’acquisition de chaînes Get

Get_line

Skip_line vide un buffer, passe une ligne Ex :

Chaîne : string (1..5) ;

Voir ADA11_01 Voir ADA11_02 Voir ADA11_03

II Les chaînes de caractères

Dans standard, il existe

Type_string is array (positive range <>) of character ; Chaîne1 : string (1..10) ;

Chaîne2 : string (1..20) ;

Chaîne3 : constant string := »exemple » ; De longueur 7

Put(chaîne3(2)) ;->X

COURS du 24 janvier 2005 Voir ADA11_04

III Complément : paquetage ADA.characters.handling

Voir ADA11_07

IV Complément : paquetage ADA.strings.fixed

Voir ADA11_08

Chapitre 11 : Traitement des chaînes de caractères,

introduction aux fichiers

(34)

I Introduction

I - 1 Définition

C’est la possibilité de faire figurer dans l’objet une référence à l’objet lui-même L’objet peut être : fonction, procédure, programme récursif, structure de données

I - 2 Exemple de relation récursive

Soit parenté : relation de « parent » entre 2 personnes X et Y sont parents si :

Soit Y est père, mère, fils, fille de X

Soit il existe un individu Z tel que X est soit parent de Z et Z parent de Y On considère l’ordre alphabétique des lettres

A<B<C<……Z

On appelle mot, une suite de lettres

La propriété X est avant Y (X et Y sont des mots)

Pour X<>Y , on définit X est avant Y tel que X est un mot vide Y n’est pas un mot vide X et Y ne sont pas vides

La 1^ère lettre de X précède la 1^ère lettre de Y X et Y ne sont pas vides

Leurs premières lettre sont identiques

Le mot obtenu en retirant à X la 1^ère lettre est avant celui obtenu en retirant à Y sa 1^ère lettre

COURS du 31 janvier 2005 Définition d’un identificateur

Il sert à caractériser un objet ADA (variable, fonction, procédure, packages, tâches, paramètre) Identificateur

On commence par lettre, exemple nombre_01

Chapitre 15 : Récursivité

LETTRE

Identificateur

Chiffre Lettre

(35)

Formes prises par la récursivité Récursivité directe

On a des sous algorithmes récursifs Fonction

Procédure

Définition : le texte contient n ou plusieurs appels à la fonction( ou procédure) elle même Récursivité croisée ou indirecte

La procédure A appelle la procédure B qui appelle la procédure A à son tour Structure de données

RGD Recherche Gauche Droite

II La récursivité des actions

II - 1 la factorielle

N ! = N * (N-1) * (N-2) * …*1 Ecriture itérative (boucle) inter

Resultat<-1 -- factorielle N inter<-N tq inter>=2

resultat<-resultat*inter inter<-inter-1

ftq

retour resultat

Voir ADA15_01

(36)

Ecriture récursive

(n-1) !=(n-1)*(n-2)*….*2 n !=n*(n-1) !

n ! fait appel à factorielle fonction factorielle (n) si n = 0 alors

retour 1 sinon

retour n*factorielle(n-1) fin si

fin fonction factorielle

Voir ADA15_02

II - 2 PGCD, Plus Grand Commun Diviseur

Méthode itérative Lire A

Lire B Tq A <> B

Si A>B alors A<-A-B Sinon

B<-B-A Fin si

Ftq

PGCD<-A(ou B) Exemple :

A B

24 12

12 A=B

PGCD=12 54 24 30

6

18 12 6

Voir ADA15_03

(37)

Méthode récursive If A-B = 0 then

Return A;

Else

If A>B then

Return fo_pgcd.rec(A-B, B);

Else

Return fo_pgcd.rec(A, B-A);

End if;

II - 3 Les tours de Hanoï

Sujet

64 disques posés les uns sur les autres par taille décroissante

transfert des 64 disques d’un socle d’origine vers un socle but en utilisant un socle intermédiaire A, B, C : nom des socles

Déplacement autorisé 1 seul disque à la fois

on pose un disque plus petit sur un disque plus grand (et pas l’inverse) Paramétrage

X

X X X

X X X X X

A B C

Procedure deplacer(X,Y)

Simplification du problème en étudiant les mouvements avec 3 disques Le sur lignage bleu indique le mouvement retenu

Mouvements autorisés A vers B

A vers C

X X X

X X X X X X

A B C

Mouvements autorisés B vers A

B vers C A vers C

(38)

X X X X X X X X X

A B C

Mouvements autorisés B vers C

B vers A C vers B

X

X X X X X X X X

A B C

C vers A C vers B

X

X X X X X X X X

A B C

Mouvements autorisés B vers A

C vers B C vers A

X X X X X X X X X

A B C

Mouvements autorisés C vers B

A vers B A vers C

X X X

X X X X X X

A B C

(39)

A vers C B vers C

X

X X X

X X X X X

A B C

Il y a eu 7 déplacements avec 3 disques Avec 4 disques, il y a 15 déplacements

Nombre de déplacement = 2ⁿ – 1, n étant le nombre de disques Recherche d’une solution récursive

- paramétrage (paramètres formels) nombre de disques : n

socle départ : x socle d’arrivée : y socle intermédiaire : z

- recherche des cas triviaux si n=0 alors

rien fin si si n=1 alors

delacer (x,y) fin si

- reduction du cas général

la pile a 2 éléments : le haut de la pile avec n-1 disques le bas de la pile avec 1 disque

X

X X X

X X X X X

A B C

Hanoï (n-1, a,c,b)

X

X X X X X X X X

A B C

(40)

Deplacer(a,b) Ou

Hanoï (1,a,b,c)

X

X X X X X X X X

A B C

Hanoï (n-1,c,b,a)

X

X X X

X X X X X

A B C

Voir ADA15_05 Le socle intermédiaire se calcule par 6-i-j

Socle a : 1 Socle b : 2 Socle c : 3 1+2+3 = 6

COURS du 07 février 2005 Voir ADA15_06

On place une trace dans le programme afin de suivre son exécution

(41)

I Déclaration et instanciation

Le but de la généricité est de décrire un modèle quelque soit le type de données.

Voir Pr_echanger.ads et Pr_echanger.adb

II Généricité et procédures

Sans généricité, pour échanger des entiers, il faut utiliser 1 procédure, 1 autre pour les réels et encore 1 dernière pour les caractères. Afin d’éviter cela, on écrit :

Voir Pr_Gen_Echanger.ads et Pr_Gen_Echanger.adb Dans Pr_Gen_Echanger.ads : le mot clef est generic

Item désigne un mot quelconque

Private indique que la définition d’item sera donnée plus tard dans le programme

Dans Pr_Gen_Echanger.adb : Quelque soit le type l’échange se fait de la même façon Voir ADA16_02

III Généricité et package

Utilisation d’un package générique

Voir ADA16_03

IV Utilisation du pakage Pa_Gen_Pile

V Généricité et tri

Voir ADA16_06