Algorithmique Procdurale - PowerPoint PPT Presentation

1 / 109
About This Presentation
Title:

Algorithmique Procdurale

Description:

R sum des diff rentes structures de boucle en ADA. Bloc d claratif AP ... Tous les ordinateurs actuels sont des machines de Turing, la restriction pr s ... – PowerPoint PPT presentation

Number of Views:192
Avg rating:3.0/5.0
Slides: 110
Provided by: robil
Category:

less

Transcript and Presenter's Notes

Title: Algorithmique Procdurale


1
Algorithmique Procédurale
  • IUP GMI 1ère année
  • Denis Robilliard

2
Sommaire
  • Introduction
  • Historique
  • La machine de Turing
  • Langages de programmation
  • Arbres programmatiques et Ada
  • Syntaxe, expressions régulières
  • Premier programme
  • Premier programme en Ada
  • Instructions

3
  • Commentaires
  • Variables, affectations
  • Types de base
  • Opérations arithmétiques de base
  • Entrées/sorties sur les types de base
  • Inclure des bibliothèques
  • Conversions de types
  • Structures de contrôle du flux d instructions
  • Structure d'alternative AP / ADA
  • Expressions booléennes, opérateurs relationnels

4
  • Structure de cas AP / ADA
  • Expression statique ou dynamique
  • Phases d'écriture d'un programme
  • Structure de boucle AP /ADA
  • Boucle "pour" AP / ADA
  • Boucle avec sortie
  • Résumé des différentes structures de boucle en
    ADA
  • Bloc déclaratif AP /ADA
  • Types tableaux
  • Tableaux AP / ADA

5
  • Exemple sur les tableaux
  • Règles, opérations et attributs de tableaux
  • Les tranches
  • Les agrégats
  • Les chaînes de caractères AP / ADA
  • Entrées / sorties sur les chaînes
  • Attributs relatifs aux chaînes et aux caractères
  • Les tableaux à plusieurs dimensions
  • Les sous-programmes procédures et fonctions
  • Paramètres et valeur de retour

6
  • Paramètres par défaut
  • Position des procédures et des fonctions
  • Déclarations préliminaires
  • Portée et visibilité
  • Récursivité
  • Retour sur les types, enregistrements

7
Introduction
  • Algorithmique "art" d écrire des algorithmes
    ou programmes.
  • Synonyme programmation.
  • Algorithme procédé opératoire qui permet, à
    partir de données, d obtenir un résultat précis.
  • Ex algo de l addition de deux nombres.

8
  • Algo procédurale (ou encore impérative) les
    programmes sont conçus comme une liste d ordres
    / instructions, qui doivent s exécuter un par
    un, dans un ordre chronologique défini à
    l avance.
  • Il existe d autres formes d algo parallèle,
    objet, fonctionnelle, déclarative, ...

9
Historique
  • Premiers algorithmes dès l Antiquité Euclide,
    Eratosthène,
  • Premières machines à calcul Pascal, Descartes
    (17ème), algorithme "codé" par des engrenages.
  • Premier véritable ordinateur la machine de
    Babbage (19ème), non achevée. Nouveauté elle
    est programmable.

10
  • Première personne à programmer Lady Ada
    Lovelace, "assistante" de Babbage.
  • Théorisation Turing, Church (années 30),
    définition de la notion mathématique de "fonction
    calculable" ce qui peut être réalisé par un
    "ordinateur universel".
  • Premiers ordinateurs électroniques mis au point
    pendant la 2nde guerre mondiale.

11
La machine de Turing
  • Un "ordinateur" de papier
  • une bande de papier, finie mais aussi longue
    qu on le souhaite, divisée en cases qui peuvent
    contenir les symbole 0 ou 1
  • une "tête" de lecture/écriture qui pointe sur une
    case, qui peut lire ou écrire un 0 ou un 1 dans
    la case, et qui peut se déplacer d une case à
    droite ou à gauche
  • (voir page suivante)

12
  • un programme, composé de règles de la forme
    ltq, sgt ltq , s , pgt
  • avec q, q  des états de la machine de Turing,
    dont le nombre, toujours fini, est dépendant du
    programme que l on exécute
  • s, s  dans 0,1 les symboles que l on peut
    écrire sur la bande
  • p dans g,d une direction indiquant vers quelle
    case voisine (gauche ou droite) se déplace la
    tête de lecture pour exécuter la prochaine
    instruction

13
  • Représentation de la machine de Turing

...
Tête de lecture dans la configuration de départ
...
Position de la tête de lecture et état de la
bande après application de la règle ltq0, 0gt
ltq1, 1, dgt
q1
14
  • Exemple de programme
  • Objectif le programme va lire un nombre en base
    1 composé de 2 chiffres au plus. Il va écrire le
    double de ce nombre, en base 1, plus loin sur la
    bande.
  • Note la bande sera donc divisée (virtuellement)
    en une zone de données de deux cases suivie
    d une zone de résultat. La donnée en entrée est
    écrite sur la bande par l utilisateur.

15
  • Le programme
  • ltq0, 0gt ltq10, 0, dgt
  • ltq0, 1gt ltq11, 1, dgt
  • ltq10, 0gt ltq20, 0, dgt
  • ltq10, 1gt ltq21, 1, dgt
  • ltq11, 0gt ltq21, 0, dgt
  • ltq11, 1gt ltq22, 1, dgt
  • ltq20, 0gt ltqF, 0, dgt
  • ltq21, 0gt ltq311, 1, dgt
  • ltq311, 0gt ltqF, 1, dgt
  • ltq22, 0gt ltq321, 1, dgt
  • ltq321, 0gt ltq422, 1, dgt
  • ltq422, 0gt ltq523, 1, dgt
  • ltq523, 0gt ltqF, 1, dgt
  • Note
  • q0 est l état initial de la machine
  • qF est l état final quand la machine passe
    dans l état qF elle s arrête

16
  • Tout ce qui peut être calculé par une machine de
    Turing ensemble des fonctions calculables
  • Tous les ordinateurs actuels sont des machines de
    Turing, à la restriction près que leur mémoire
    est finie.
  • Il existe des fonctions non calculables !!! Un
    ordinateur ne peut pas tout faire...

17
Langages de programmation
  • Pour communiquer l idée d un algo, à une
    personne ou à un ordinateur, nécessité d un
    langage.
  • En général les langages informatiques sont
    universels (ils permettent de coder tous les
    programmes possibles).
  • Cependant, ils favorisent souvent une certaine
    approche des problèmes
  • Pascal, C programmation procédurale
  • Smalltalk, Eiffel, Java programmation objet
  • Prolog programmation déclarative

18
Arbres Programmatiques et Ada
  • Nous utiliserons 2 langages
  • Un langage pédagogique, en partie graphique, noté
    AP les Arbres Programmatiques. Note ce ne
    sont pas des organigrammes.
  • Un langage "de la vraie vie" ADA. C est un
    langage de programmation procédurale, créé en
    1983 sur appel d offre du Département de la
    Défense américain. Il possède, depuis 1995, des
    extensions objets, que nous n utiliserons pas.

19
  • Pourquoi les arbres programmatiques ?
  • C est une notation "papier" (nous n exécuterons
    pas un AP sur machine). Nous nous permettrons une
    syntaxe plus souple.
  • Les APs forcent le programmeur à une approche
    hiérarchique, descendante du problème.
  • C est la "programmation structurée"
  • On part des idées générales et on va
    progressivement de plus en plus dans le détail.
  • Les branches d'un arbre programmatique sont assez
    indépendantes les unes des autres (au moins en ce
    qui concerne le déroulement des instructions).

20
  • La programmation procédurale structurée marche
    très bien pour concevoir de petites applications
    (- de 5000 lignes).
  • D autres approches, notamment la conception
    objet, seront vues plus tard dans le cursus pour
    les applis plus importantes.
  • Note le code de la navette spatiale américaine
    fait plus de 1.000.000 de lignes...

21
Syntaxe, expressions régulières
  • Pas de langage sans syntaxe (ou orthographe)
  • Nous utiliserons une forme restreinte des
     expressions régulières  pour définir
    précisément la syntaxe autorisée,
    particulièrement en Ada.
  • Exemple
  • identifiant lettre _ / lettre
    chiffre /
  • Ce qui signifie qu un identifiant commence
    forcément par une lettre et se continue par une
    suite, éventuellement vide, de lettres et/ou
    chiffres, qui peuvent chacun être précédé d'un
    "blanc souligné".

22
  • Symboles formant les expressions rationnelles
  • introduit l expression rationnelle qui
    définit la syntaxe associée au concept 
  • délimitent une sous-expression facultative
  • délimitent un motif qui peut être répété
  • désigne un terme identique au terme précédent
  • (barre verticale) "ou bien" dans une
    énumération
  • \ \ délimitent une série d'option d'options
    parmi lesquelles il faut choisir une
  • en_gras dénote un mot réservé (mot clé) de ADA
    ou un symbole à prendre littéralement.

23
Premier programme
bonjour nb entier
seq
demander nombre
afficher nombre
saluer
sortir("le nombre est  ") sortir(nb)
sortir("bonjour")
24
Premier programme en Ada
  • with text_io, integer_text_io
  • use text_io, integer_text_io
  • procedure bonjour is
  • nb integer
  • begin
  • -- saluer
  • put_line("bonjour")
  • -- demander nombre
  • put("entrez votre nombre ") get(nb)
  • -- afficher nombre
  • put("le nombre est  ") put(nb)
  • end bonjour -- le rappel du nom d'unité est
    facultatif

25
Instructions
  • Un programme est composé d instructions. Une
    instruction peut elle-même contenir d autres
    instructions.
  • Par défaut, les instructions s'exécutent en
    séquence.
  • En Ada les instructions sont terminées par un
    point virgule (facultatif en AP).
  • Une instruction peut s étendre sur plusieurs
    lignes.
  • Pas de différence entre majuscules et minuscules

26
Commentaires
  • Les commentaires ont pour objectif de faciliter
    la compréhension du programme.
  • Les noms de bloc d instructions AP seront
    toujours reportés comme commentaires en Ada. Des
    commentaires supplémentaires seront évidemment
    les bienvenus.
  • Les commentaires débutent par -- et se
    poursuivent jusque la fin de ligne.

27
Variables, affectation
  • Chaque donnée (nombre, caractère, ) que l on
    veut réutiliser ultérieurement doit être stockée
    dans un emplacement mémoire appelé "variable".
  • Les 2 langages, AP et ADA, sont "fortement typés"
    une variable ne peut contenir qu une seule
    sorte ou "type" de données (soit un caractère,
    soit un nombre entier, )

28
  • Les variables utilisées par un programme doivent
    être "déclarées" avant leur utilisation on
    précise leur nom et l unique type de valeur
    qu elles peuvent contenir.
  • L affectation est une instruction. Elle sera
    noté en AP et en ADA.
  • nb 2 -- range la valeur 2 dans nb

29
Types de base
  • Nous utiliserons 4 types de base
  • entier (Ada integer) nombres sans virgule
  • flottant (Ada float) nombres avec virgule. Un
    flottant s'écrit toujours flottant chiffre
    "." chiffre
  • ex 0.0 0.5 123.45
  • ctr-ex .0 3 324.
  • Notation exponentielle pour les flottants
  • 1.23e2 1.23E2 1.23 102 123.0

30
  • caractère (Ada character) 'A', 'b', '?', ...
  • booléen (Ada boolean) valant Vrai ou Faux
    (Ada True, False)

31
Opérations arithmétiques de base
  • Les 4 opérations - /
  • Attention, sur des entiers le résultat est
    arrondi à l entier le plus proche
  • nb 3 / 2 -- nb contient 1
  • Il est interdit de mélanger des types différents
    dans une opération quelconque
  • nbf 3.0 / 2 -- erreur de compilation
  • nbf 3.0 / 2.0 -- ok, nb vaut 1.5

32
  • Reste et modulo de la division entière de 2
    nombres rem, mod
  • nb 3 rem 2 -- nb vaut 1
  • nb 10 mod 5 -- nb vaut 0
  • Exponentiation (entiers et flottants)
  • nb 3 2 -- nb vaut 9
  • fonctionne aussi sur les flottants
  • Valeur absolue (entiers et flottants) abs()
  • nb abs(-3) -- nb vaut 3

33
Entrées/sorties sur les types de base
  • Lecture (ou saisie) d une donnée
  • AP entrer (nom_de_variable)
  • Ada get (nom_de_variable)
  • Ada permet de spécifier le nombre maximum de
    caractères (largeur de champ) à prendre en compte
    get (nom_variable, largeur_champ)
  • Le programme s arrête, l utilisateur tape une
    donnée au clavier suivie d un retour chariot.
  • Une donnée est toujours saisie dans une variable.

34
  • Ecriture (ou sortie) d une donnée
  • AP sortir (variable donnée )
  • Ada put (variable donnée )
  • Ada permet de donner un format à la donnée
    nombre de chiffres,
  • entiers put (variable donnée , nb_chiffres)
  • flottants put (variable donnée,
    nb_chiffres_avant_virg , nb_chiffres_apres_virg ,
    nb_chiffres_exposant)

35
  • Exemples de sorties
  • put(123) put(12345678) put(123,2) put('A')
    put('A') -- écrit 123 12345678123AA
  • Note le format par défaut des entiers est 8
    caractères de large. Un format trop petit est
    ignoré.
  • put(123.456) -- écrit 1.23456E2
  • put(123.456, 2, 2, 0) -- écrit 123.45
  • Note par défaut les flottants sont écrits en
    notation scientifique. Si la mantisse est trop
    grande, le format est partiellement ignoré.

36
Inclure des bibliothèques
  • En Ada, les entrées/sorties ne sont pas intégrées
    au langage il est nécessaire d inclure les
    bibliothèques spécifiques qui contiennent ces
    instructions optionnelles.
  • Text_io saisie et sortie de caractères
  • Integer_text_io d entiers
  • Float_text_io de flottants
  • Note d'autres constructions peuvent nécessiter
    d'inclure d'autres bibliothèques...

37
  • Inclusion de biblis
  • with bibli_1, bibli_2
  • les instructions contenues dans la bibli sont
    accessible en les préfixant du nom de la bibli
  • with text_io
  • procedure aaa is
  • begin
  • text_io.put('A')
  • end aaa

38
  • Si on utilise fréquemment une instruction en
    provenance d'une bibli, le préfixage devient vite
    fatiguant, on le supprime avec "use"
  • with text_io
  • use text_io
  • put('A')

39
  • Pourquoi devoir préfixer par défaut ?
  • Utile si 2 biblis apportent des instructions de
    même nom

bibli1
programme
mon_put
with bibli1, bibli2 ... mon_put(123) ...
lequel est-ce ?
bibli2
mon_put
40
Conversions de types
  • AP et Ada sont fortement typés on ne peut pas
    mélanger des données de types différents dans une
    même expression.
  • Il est nécessaire de pouvoir convertir des
    données d un type dans un autre conversion de
    type (ou changement de type ou transtypage).
  • conversion_de_type nom_de_type ( donnée
    variable )
  • nb integer(3.5) -- nb vaut 3

41
Structures de contrôle du flux d'instructions
  • Il est souvent nécessaire que l'état d'un
    programme (contenu des variables, ) puisse
    influer sur l'ordre d'exécution des intructions.
  • C'est le rôle des structures de contrôle de
    préciser comment et à quelles conditions l'ordre
    d'exécution des instructions peut varier.

42
Structure d'alternative AP
  • Les instructions du bloc "si" ne sont exécutées
    que si la condition est vérifiée.
  • Les instructions du bloc "sinon" sont exécutées
    seulement dans le cas contraire.

43
Structure d'alternative ADA
  • if condition then
  • bloc instr.
  • else -- facultatif
  • bloc instr.
  • end if

if condition_1 then bloc instr. elsif
condition_2 then bloc instr. elsif condition_3
then bloc instr. ... else -- facultatif bloc
instr. end if
44
Expressions booléennes, opérateurs relationnels
  • Une condition est une expression booléenne.
  • Elle est vérifiée si elle vaut vrai (true).
  • Opérateurs relationnels
  • lt, lt, gt, gt, , /
  • et (and), ou (or), non (not)
  • ou exclusif (xor)
  • et alors (and then), ou sinon (or else)
  • dans (in), dehors (not in)

45
Structure de cas AP
46
  • La valeur de expression doit correspondre à une
    et une seule des valeurs données dans les
    losanges.
  • Seul le bloc situé sous la bonne valeur est
    exécuté.
  • Après exécution de ce bloc, on sort de la
    structure de cas, les autres blocs sont ignorés.

47
Structure de cas ADA
  • case expr is
  • when \ expr interv_discr others \ gt
    statement
  • end case
  • Exemple
  • case nb is -- nb est une variable entiere
  • when 1 2 3 gt put("1,2 ou 3) new-line
  • when 5..10 gt put("entre 5 et 10") new_line
  • when others gt null -- instruction vide
  • end case

48
  • 3 règles à retenir pour l'ensemble des choix
  • il doit être exhaustif (d'où l'utilisation
    fréquente de others)
  • il ne doit pas y avoir de répétitions
  • les choix doivent être "statiques" (c'est à dire
    évaluables lors de la compilation)

49
Expression statique ou dynamique
  • Une expression "statique" est une expression dont
    la valeur peut être calculée lors de la
    compilation du programme.
  • Une expression "dynamique" dépend, à priori, de
    l'exécution du programme.
  • Ex le contenu d'une variable est susceptible de
    changer lors de l'exécution d'un programme (par
    définition). Par conséquent, toute expression
    qui comporte une variable est considérée comme
    dynamique, même si l'auteur du programme sait que
    le contenu de la variable en question ne sera pas
    changé !

50
Phases d'écriture d'un programme
  • Écriture du source
  • Compilation traduction du source en objet
  • Préprocesseur (nettoie le source)
  • Compilateur (traduit en assembleur)
  • Assembleur (traduit en code machine)
  • Éditeur de liens traduction de l'objet en
    exécutable, regroupement en un seul fichier des
    différents modules qui constituent le programme
  • Chargeur installe l'exécutable en mémoire, puis
    l'exécute

51
Structure de boucle AP
  • Le bloc d instruction est exécuté tant que la
    condition est vraie.

52
Structure de boucle ADA
  • while condition loop
  • bloc_instr
  • end loop
  • Exemple
  • while (nb lt 12) loop
  • put(nb)
  • nb nb 1
  • end loop

53
Boucle  pour  AP
variable de boucle
variable dans envers a..b
intervalle
facultatif
  • Le bloc d instruction est exécuté autant de fois
    que d'éléments dans l intervalle discret a..b.
  • La boucle "pour" n'est à utiliser que si on
    connait à l'avance le nombre de tours à effectuer.

54
  • La variable de boucle
  • Ne doit pas être déclarée.
  • Masque toute autre variable déjà déclarée de même
    nom, dans tout le sous-arbre du bloc
    d'instruction.
  • Contient la valeur courante dans l intervalle.
  • Est considérée comme une constante dans le bloc
    d instruction on ne peut pas la modifier.
  • Attention
  • Si b lt a, l intervalle est vide, on ne le
    parcourt pas !
  • Si on souhaite parcourir l intervalle à
    l envers, utiliser le mot-clé  envers .

55
Boucle  pour  ADA
  • for variable in reverse intervalle loop
  • bloc_instr
  • end loop
  • Exemples

for i in 1..10 loop put(i) end loop
for i in character'('A')..character'('Z')
loop put(i) end loop
56
  • -- n affiche rien !
  • for i in 10..1 loop
  • put(i)
  • end loop
  • -- affiche de 10 à 1
  • for i in reverse 1..10 loop
  • put(i)
  • end loop

-- affiche 1 à 10, puis 3 ! i 3 for i in
1..10 loop put(i) end loop put(i) -- ne
compile pas ! for i in 1..10 loop i i
1 end loop
57
Boucle avec sortie
  • loop
  • instr
  • exit when condition -- facultatif
  • instr
  • end loop

58
  • Exemple
  • -- compte une séquence de nombres terminée par 0
  • -- nb et compteur sont des variables entières
  • put("Entrez vos nombres, terminez par 0")
    new_line
  • loop
  • get(nb)
  • exit when nb 0
  • compteur compteur 1
  • end loop
  • put("Decompte ") put (compteur) new_line

59
  • De plus, les boucles ADA peuvent recevoir un
    identifiant de boucle, qui peut se combiner avec
    l'instruction exit.
  • Bcl1 loop
  • Bcl2 loop
  • exit Bcl1
  • end loop
  • end loop

60
Résumé des différentes structures de boucle en ADA
  • id while bool_expr for id in reverse
    discrete_range loop
  • statement
  • end loop id
  • exit loop_id when bool_expr

61
Bloc déclaratif AP
  • Il peut être utile de déclarer des variables pour
    un usage momentané leur portée peut être
    réduite au bloc d'instruction où elles servent.
  • En AP

62
Bloc déclaratif ADA
  • id declare
  • declarative_item
  • begin
  • handled_statement
  • end id
  • handled_statement
  • statement
  • exception_handler

63
  • Le "handled_statement" est un simple bloc
    d'instructions, qui se termine par un traitant
    d'exceptions des instructions servant à
    rattraper d'éventuelles erreurs lors de
    l'exécution.
  • Exemple de bloc déclaratif
  • declare
  • tmp integer
  • begin
  • tmp A A B B tmp
  • end

64
Types tableaux
  • De nombreuses applications nécessitent de
    mémoriser des séries de variables composantes
    de vecteurs ou de matrices, tables de température
    ou de pression,
  • On peut stocker ces données dans une structure
    simple appelée tableau, à l'intérieur de laquelle
    chaque donnée est associée à un ou plusieurs
    numéros appelé indices.
  • On accède à une donnée en rappelant le nom du
    tableau et son ou ses indices.

65
Tableaux AP
  • Représentation d'un tableau à 1 dimension

indices
temperatures
nom du tableau
variables
temperatures(1)
temperatures(6)
  • Une variable de type tableau doit être déclarée,
    en précisant le type unique des valeurs contenues
    dans le tableau et les bornes du tableau
  • temperatures tableau (1..8) d'entiers

66
Tableaux ADA
  • On peut les déclarer comme des variables
  • tab1 array(1..8) of integer
  • tab2 array(1..8) of integer
  • Attention, tab1 et tab2 sont considérés comme
    étant de types différents
  • pas d'affectation possible au niveau tableau sans
    une conversion.
  • pas de possibilité de les passer en paramètre à
    une fonction ou à une procédure (voir plus loin).

67
  • En général, on déclare un type tableau avant de
    déclarer les variables
  • type tab_int_8 is array(1..8) of integer
  • tab1, tab2 tab_int_8
  • Pas de problème d'affectation, ni de passage en
    paramétre.
  • Les déclarations de types se placent dans la
    partie déclarative d'une unité de compilation ou
    d'un bloc déclaratif.
  • Nous utiliserons la même convention en AP.

68
Exemple sur les tableaux
seq
pour
seq
Sortir(max)
Comparer avec tous
Entrer(tab(i))
pour
max tab(1)
max tab(i)
69
-- comparer avec tous for i in 2..Taille
loop if max lt tab(i) then max
tab(i) end if end loop -- afficher
max put("le max est ") put(max) new_line en
d max_tab
  • Procedure max_tab is
  • Taille constant 20
  • type Tab20Int is array(1..Taille)
  • of integers
  • max integer
  • tab Tab20Int
  • begin
  • -- saisie
  • put_line("entrez le tableau")
  • for i in 1..Taille loop
  • get(tab(i))
  • end loop
  • -- determiner max
  • -- initialiser
  • max tab(1)

70
Règles, opérations et attributs de tableaux
  • un tableau ne peut contenir qu'un seul type
    d'éléments
  • on ne peut pas utiliser un indice en dehors des
    bornes définies à la déclaration du tableau, sous
    peine de "plantage"
  • on peut affecter un tableau à un autre tableau
    s'ils sont compatibles même taille, même type
    d'éléments (une conversion de type peut être
    nécessaire)
  • a, b tab_int
  • a b

71
  • Un tableau connaît
  • ses bornes a'first, a'last
  • l'intervalle des indices corrects a'range
    (équivalent à a'first..a'last)
  • la longueur de cet intervalle a'length
  • On peut comparer des tableaux (lt, gt, lt, gt)
    selon le principe de l'ordre lexicographique
  • quand tout est égal, un tableau plus court est
    considéré comme plus "petit" ou "avant" dans
    l'ordre.
  • On peut concaténer des tableaux avec
  • a(1..10) b(1..5) c(2..6)

72
Les tranches
  • On peut extraire un "morceau" de tableau, il
    suffit que les indices soient contigus
  • a, b tab_int
  • a(1..5) b(6..10)
  • Attention lors d'une telle affectation à vérifier
    que les 2 tranches soient de même taille.
  • Les tranches peuvent se superposer
  • a(1..5) a(2..6) -- décale la tranche 2..6
    d'une case

73
Les agrégats
  • Permettent d'initialiser les tableaux
  • declare
  • type TABLE is array(4..9) of integer
  • t TABLE (1, 2, 3, 4, 5, 6)
  • begin
  • t TABLE'(4 6 gt 1, others gt 0)
  • t TABLE'(4..7 gt 2, 8..9 gt 3)
  • end

74
Les chaînes de caractères AP
  • Les chaînes de caractères sont des données très
    utilisées il existe un type chaine prédéfini.
  • Le type chaine est un en fait un tableau de
    caractère, avec une syntaxe raccourcie
  • ch1, ch2 chaine(1..8) -- conseillé
  • ch3 tableau(1..8) de caractères -- déconseillé
  • Attention, dans l'exemple précédent ch1 et ch2
    sont de même type, mais pas ch3, bien que ces 3
    objets soient représentés de manière identique en
    mémoire.

75
Les chaînes de caractères ADA
  • En ADA, on dispose du type STRING
  • ch1, ch2 string(1..8) -- conseillé
  • ch3 array(1..8) of character -- déconseillé
  • Comme en AP, ch1 et ch2 sont de même type, mais
    pas ch3, bien que ces 3 objets soient représentés
    de manière identique en mémoire.
  • Accès
  • ch1(1) ch2(8)
  • ch1(1..5) ch2(1..2) ch2(2..4)

76
Entrées/sorties sur les chaînes
  • Entrée
  • get(ch1) -- attention, taper exatement 8
    caractères!!!
  • get_line(ch1, lng1) -- le nombre de cars tapés
    sera
  • -- rangé dans lng1, qu'il faut déclarer (var.
    entière).
  • Sortie
  • put(ch1)
  • put_line(ch1) -- passe à la ligne suivante
  • -- !!! Put_line ne fonctionne qu'avec des
    chaînes !!!

77
Attributs relatifs aux chaînes et aux caractères
  • Image renvoie la représentation d'un type sous
    forme de chaîne.
  • Value renvoie la "valeur" d'une chaine.
  • Pred, Succ le précédent et le suivant.
  • Pos, Val la position et son inverse

Character'pred('2') '1' Character'succ('A')
'B' Character'pos('0') 48 Character'val(48)
'0'
Integer'image(300) "300" Character'image('z')
"z" Integer'value("300") 300 Character'value("
'z' ") 'z'
78
Les tableaux à plusieurs dimensions
  • Array_type_def
  • array (discrete_range , ) of type
  • Exemple
  • type MATRICE is array(1..10, 1..10, 1..10) of
    float
  • type TAB_2D is array(1..5, -1..0) of integer
  • m1, m2 MATRICE
  • t TAB_2D

79
  • Accès
  • m1(1,1,1) m2(1,1,10)
  • get(m1(i,j,k))
  • Agrégats
  • t TAB_2D'((1,1), (2,2), (3,4), (4,5), (5,5))
  • t TAB_2D'((1,1), (2,2), others gt (3,3))
  • t TAB_2D'(1 3 gt (1,1), others gt (0,0 )
  • t TAB_2D'(others gt (-1 gt 1, others gt 0))
  • t TAB_2D'(others gt (others gt 0))

80
  • Attributs
  • first(i), last(i), range(i), length(i) où i est
    le numéro de la dimension
  • t'first(1) 5
  • t'first(2) -1
  • t'range(1) 1..5
  • t'range(2) -1..0
  • first(1), last(1), range(1), length(1) se notent
    aussi first, last, range, length.

81
Les sous-programmes procédures et fonctions
  • Subprogram_body
  • subprogram_spec is
  • declarative_item
  • begin
  • handled_statement
  • end
  • Subprogram_spec
  • procedure parent_name.id formals
  • function parent_name.id formals return
    subtype_name

82
  • Formals
  • (id , id in in out out subtype_name
  • expr )
  • Exemples
  • procedure efface_ecran is
  • procedure passe_lignes (x integer) is
  • function lire_entier return integer is
  • function perimetre (rayon float) return float
    is
  • procedure peri_surf (rayon in float perimetre,
    surface out float) is ...

83
Un sous-programme est exécuté à chaque appelLors
de l'appel, le paramètre formel prend la valeur
du paramètre effectif
Paramètre effectif
Paramètre formel
Flux des instructions
procedure exemple is begin passe_lignes(2)
N 10 passe_lignes(N) end exemple
procedure passe_lignes(X integer) is begin for
cpt in 1..X loop new_line end loop end
passe_lignes
Spécification de sous-programme
Appels de sous-programme
84
  • Les sous-programmes servent
  • à éviter les répétitions inutiles de code,
    lorsqu'un ensemble d'instructions sert à
    plusieurs endroits.
  • à structurer le programme en isolant des
    fonctionnalités spécifiques dans des
    sous-programmes séparés c'est comme si on
    ajoutait de nouvelles instructions de base.
  • Les sous-programmes doivent
  • éviter au maximum d'utiliser des variables
    déclarées en dehors d'eux-mêmes utiliser les
    paramètres pour communiquer les données.
  • conserver une taille raisonnable pour pouvoir
    être compris et mis au point sans pb au maximum
    60 lignes

85
Position des procédures et fonctions
  • 1) Dans des fichiers séparés, un par
    procédure/fonction
  • On les inclus dans le programme principal avec
    "with nom_proc" (le fichier doit avoir le même
    nom).
  • La clause "use" n'est pas nécessaire.
  • Elles ne connaissent pas les types/variables du
    programme principal !
  • 2) Dans la procédure principale, dans la section
    déclarative (là où on place les déclarations de
    types, de variables, )
  • Elles connaissent les déclarations placées avant.

86
Déclarations préliminaires
  • Une procédure ne peut en appeler une autre qui
    soit déclarée après
  • C'est génant, obligation de bouger le morceau de
    code à la bonne place.
  • C'est parfois inextricable si p1 appelle p2 et
    p2 appelle p1, bouger le code n'est pas la
    solution.
  • On recourt à une déclaration préliminaire, que
    l'on place le plus haut possible
  • Même syntaxe qu'une déclaration ordinaire, sauf
    qu'on s'arrête au "is", qui est remplacé par ""
  • procedure lire_somme (s out integer) -- decl.
    prelim.

87
Paramètres et valeur de retour
  • Les paramètres des sous-programmes et la valeur
    de retour des fonctions servent à échanger des
    données avec le programme appelant.
  • dans la déclaration du ss-prog paramètres
    formels
  • dans l'appel au ss-prog paramètres effectifs
  • Une procédure ne retourne pas de valeur, mais
    elle peut prendre des paramètres qui peuvent être
    modifiés.
  • Une fonction retourne obligatoirement une unique
    valeur. Ses paramètres ne peuvent être modifiés
    (penser aux fonctions mathématiques).

88
  • La valeur d'une fonction est retournée par
    l'instruction return expression
  • Si le flux d'instruction atteint le "end" final
    d'une fonction sans rencontrer de "return",
    l'exception "program_error" est levée.
  • On peut utiliser return dans une procédure on
    quitte la procédure en cours et on revient à
    l'appelant (rien n'est retourné).

89
  • Les modes des paramètres
  • in lecture seule (comme une constante)
  • out écriture seule
  • in out lecture / écriture (comme une variable)
  • Si on n'indique pas de mode, c'est le mode "in"
    par défaut.
  • Une fonction a toujours ses paramètres en mode
    "in".
  • Attention, en mode "out" on ne peut pas consulter
    (lire) la valeur du paramètre, ce qui peut être
    déconcertant.

90
  • Procedure lire_somme (s out integer) is
  • -- met dans s la somme des entiers saisis par
    l'utilisateur
  • n, tmp integer 0
  • begin
  • put_line("entrer vos entiers (terminer par
    -1)")
  • get(n)
  • while n / -1 loop
  • -- s s tmp est interdit (car mode "out")
  • tmp tmp n
  • get(n)
  • end loop
  • s tmp -- on a seulement le droit d'ecrire
    dans s
  • end

91
Paramètres par défaut
  • Les paramètres peuvent recevoir une valeur par
    défaut on n'est alors pas obligé de les
    fournir.
  • Dans text_io, "new_line" est déclaré ainsi
  • procedure new_line (spacing positive 1) is
  • On peut appeler new_line sans paramètre, dans ce
    cas new_line passe 1 seule ligne.

92
Portée et visibilité
  • Portée d'une entité (type, variable, constante)
    partie du code où sa déclaration est effective,
    c'est à dire où l'entité existe.
  • Visibilité d'une entité partie du code où
    l'entité est accessible.
  • La visibilité est toujours incluse dans la portée
    on ne peut accéder qu'à une entité qui existe.
  • La visibilité est souvent plus réduite que la
    portée masquages temporaires par des entités
    portant le même nom et plus locales.

93
  • Toute entité déclarée dans la partie déclarative
    d'un sous-programme ou d'un bloc "declare"
  • n'est visible que dans ce sous-programme ou ce
    bloc.
  • disparaît une fois le sous-programme ou le bloc
    terminé.

94
  • With use
  • Procedure portee_visibilite is
  • A constant 123
  • B integer A 1 -- debut de la visibilite
    de A
  • C integer 12 -- debut de la visibilite de
    B
  • function f (B character integer'image(C)(2))
    -- debut visibilite C
  • return integer is
  • C integer 0 -- debut de la visibilite de
    B de f
  • begin -- debut de la visibilite de C de f
  • return character'pos(B) C
  • end
  • begin -- retour de la visibilite de B et C après
    masquage dans f
  • put(A) put(f('A')) put(f) put (B) put(C)
    put(integer'image(C))
  • -- affiche 123 65 49 124
    12 12
  • end portee_visibilite

95
Récursivité
  • Un sous-programme peut s'appeler lui-même
  • function factorielle(N integer) return integer
    is
  • begin
  • if N 0 then
  • return 1 -- condition d'arrêt
  • else
  • return N factorielle(N - 1) -- appel
    récursif
  • end if
  • end factorielle

96
  • CE QU'IL FAUT COMPRENDRE
  • chaque niveau d'appel récursif crée sa propre
    copie des paramètres formels et des variables
    locales.
  • lors du retour d'un appel récursif on retrouve
    donc intactes les valeurs des paramètres et des
    variables (sauf si elles ont été passées
    récursivement en mode "out", bien entendu !)
  • dans le code du sous-programme, il doit y avoir
    une alternative où on ne relance pas un appel
    révursif, sinon la récursion est infinie
    (concrètement ça plante après avoir saturé la
    mémoire de la machine).

97
  • Plusieurs sous-programmes peuvent s'appeler les
    uns les autres

-- conjecture de syracuse get(N) put(syracuse1(N)
)
98
  • Attention, dans l'exemple précédent on a besoin
    de déclarations préliminaires pour compiler.
  • Comment aborder un problème récursif ?
  • Il faut avoir l'intuition qu'il se traite
    récursivement. Si on ne sait pas le traiter de
    manière classique, ça ne coûte rien de se poser
    la question
  • Il faut déterminer sur quelle "variable" (ex N)
    on fait la récurrence.
  • Il faut avoir une solution d'arrêt de la
    récursivité (quand N est petit).
  • Supposant avoir la solution au rang N-1, trouver
    ce qu'il faut faire pour passer au rang N.

99
Retour sur les types
  • Type / Sous-type
  • une déclaration de type est statique
  • type mon_entier is range 1..100 -- ok
  • N integer 100 -- variable, non statique
  • type mon_entier2 is range 1..N -- interdit !!!
  • une déclaration de sous-type peut être dynamique,
    elle s appuie sur un type pré-existant
  • N integer 100 -- variable
  • subtype mon_entier3 is integer range 1..N

100
  • Types entiers
  • with ada.text_io use ada.text_io
  • procedure test_instanciation is
  • type mon_entier is range 1..100
  • package mon_entier_io is new
    ada.text_io.integer_io(mon_entier)
  • use mon_entier_io -- autorise les E/S sur ce
    nouveau type
  • n mon_entier
  • begin
  • put("entrer un entier ")
  • get(n) -- raise DATA_ERROR si pas dans 1..100
  • put(n 2) -- raise CONSTRAINT_ERROR si pas
    dans 1..100
  • end

101
  • Types énumératifs
  • with ada.text_io, ada.integer_text_io
  • use ada.text_io, ada.integer_text_io
  • procedure test_type_enumere is
  • type JOUR is (LUNDI, MARDI, MERCREDI, JEUDI,
    VENDREDI, SAMEDI, DIMANCHE)
  • package jour_io is new ada.text_io.enumeration_
    io(jour)
  • use jour_io
  • n integer
  • begin
  • put("entrer un entier ")
  • get(n)
  • put(JOUR'VAL(n mod 7))
  • end

102
  • Attributs pour types énumérés
  • jour'first LUNDI
  • jour'last DIMANCHE
  • jour'succ(LUNDI) MARDI
  • jour'pred(MARDI) LUNDI
  • jour'pos(LUNDI) 0
  • jour'val(0) LUNDI
  • jour'value("LUNDI") LUNDI
  • jour'image(LUNDI) "LUNDI"

103
  • Type booléen
  • type boolean is (FALSE, TRUE) -- type énuméré
  • Types flottants
  • On peut préciser le nombre de chiffres
    significatifs digits N précision au 1/10N
  • On peut limiter l'intervalle des valeurs
    possibles
  • type REEL is digits 6
  • type VOLTAGE is digits 5 range 0.0 .. 1.0E9
  • Attributs
  • type FL is digits D range I..S
  • FL'digits D FL'first I FL'last S
  • E/S instancier ada.text_io.float_io(nom_type)

104
  • Types tableaux contraints / non contraints
  • tableaux contraints
  • type vecteur1 is array(1..10) of float
  • v1, v2 vecteur1
  • toutes les variables de type vecteur1 ont mêmes
    dimensions
  • tableaux non contraints
  • type vecteur2 is array(integer range ltgt) of
    float
  • v1 vecteur2(1..10)
  • v2 vecteur2(-5..15)
  • v1 et v2 sont de même type, mais de dimensions
    différentes
  • on doit fournir les bornes lors d'une déclaration
    de variable de type vecteur2

105
  • Intérêt des tableaux non contraints
  • Quand ils apparaissent en tant que paramètres
    formels, il n'est pas nécessaire de préciser leur
    taille (car ce n'est pas une déclaration de
    variable)
  • Procedure truc(v in out vecteur2) is
  • On utilise les attributs de tableau pour
    connaître l'intervalle des indices.
  • Rappel les chaînes de caractères
  • En fait le type STRING est simplement un type
    tableau de caractères non contraint
  • type STRING is array(integer range ltgt) of
    character

106
  • Type Article / Enregistrement (record)
  • Si un tableau est une collection de variables de
    même type accessibles via leur numéro, un article
    est une collection de variables de types qui
    peuvent être différents, accessibles par leur
    nom.
  • Les différentes variables de l'article
    s'appellent des champs.
  • La variable de type article possède son propre
    nom, on accède à ses champs par la notation
    pointée
  • nom_d_article.nom_de_champ

107
  • Exemple
  • type MOIS is (Janvier, Fevrier, , Decembre)
  • type DATE is record
  • jour integer range 1..31
  • mois MOIS
  • an integer
  • end record
  • d DATE
  • d (14, Juillet, 1789)
  • d (jour gt 14, an gt 1789, mois gt Juillet)
  • d.mois Mars d.jour 12 d.an d.an 1

108
  • Type Article avec partie variante
  • type Genre_Figure is (un_cercle, un_point,
    un_carre)
  • type Point is record
  • X, Y Integer
  • end record
  • type Figure (Sorte Genre_Figure un_point)
    is record
  • Position Point
  • case Sorte is
  • when un_cercle gt Rayon Integer
  • when un_carre gt Coin_Inf_Droit Point
  • when others gt null
  • end case
  • end record
  • F Figure (un_point, (10,15))
  • F (un_cercle, position gt (20, 25), rayon
    gt 50)

109
  • Partie variante comment ça marche ?
  • Entre les différents contructions rendues
    possibles dans la partie variante, le compilateur
    calcule celle qui occupe le plus de place et
    alloue cette place à la variable.
  • Dans l'exemple, c'est le carré qui prend le plus
    de place. Si on charge la variable avec un point
    ou un cercle, une partie de la mémoire reste
    inutilisée, tout simplement.
  • On ne peut changer le discriminant (variable qui
    sélectionne la partie variante) que si on change
    tout le reste de l'article.
Write a Comment
User Comments (0)
About PowerShow.com