La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Initiation à Algorithmique et programmation en ADA.

Présentations similaires


Présentation au sujet: "Initiation à Algorithmique et programmation en ADA."— Transcription de la présentation:

1 Initiation à Algorithmique et programmation en ADA

2 Infos pratiques Organisation du semestre : –Cours/TDs –Les TDs sont réalisés en binôme et notés. –Un partiel en janvier. Bibliographie : –Programmer en ADA95 par John Barnes, 2ième édition, Vuibert, ISBN X –http://crb.univ-littoral.fr/coursada/index.htm

3 Lalgorithmique Définition : –Un algorithme est une suite dinstructions qui une fois exécutée, conduit à un résultat donné. Exemple : –Fabriquer un brownie : 1 Préparer la pâte 2 Faire fondre le chocolat 3 Mélanger le chocolat et la pâte 4 Faire cuire 35 minutes Les instructions sont séquentielles, elle se suivent et doivent être réalisées lune après lautre

4 Lalgorithmique Il est possible de raffiner lalgorithme afin quil soit plus explicite : –Faire fondre le chocolat : 2.1 Placer le chocolat dans un récipient 2.2 Placer le récipient dans une casserole avec de leau bouillante 2.3 Attendre que le chocolat soit fondu Réaliser un algorithme pour un ordinateur consiste à raffiner suffisamment lalgorithme afin quil soit compréhensible pour la machine.

5 Le pseudo-code Définition –Le pseudo-code est une façon de décrire un algorithme sans référence à un langage de programmation en particulier Exemple : Programme Daboville Tantque Gérard nest pas fatigué ramer Fin Tantque Remarquez lindentation Pour rendre le code plus lisible

6 Les arbres programmatiques Il est possible de représenter le programme précédent sous la forme dun arbre programmatique Début Si Gérard nest pas fatigué Ramer Fin VRAI FAUX

7 Architecture des ordinateurs Multiplier la valeur de case 2102 par Sauter à linstruction de la case Tester si la valeur de la case 2101 est nulle 1029Incrémenter la valeur de la case Soustraire 18 à la valeur de la case 2099 Mémoire centrale Unité Centrale Lecture de linstruction Exécution de linstruction Mise à jour de la mémoire Le programme en langage machine, logé en mémoire, est exécuté par le processeur

8 Les différents langages Ajoutons 5 à la valeur dune case mémoire –En langage machine : –En assembleur : Add [I],0x05 –En ADA : I:=I+5;

9 Le langage machine/assembleur Avantages –Très rapide à lexécution, car au plus près de la machine –Adapté au développement de petits programmes critiques tels que : Les drivers Des parties du noyau des SE Inconvénients –Peu lisible -> source derreurs –Inadapté au développement de programmes de grandes tailles, au développement par plusieurs équipes –………

10 Les langages évolués Exemples –ADA, C/C++, Java, …. Avantages –Adaptés à la réalisation de gros projets grâce à : Un style « plus humain » des programmes Labstraction des données (par exemple I) …. Inconvénients –Plus lent que lassembleur –…..

11 L ADA Historique : –Commande du département Américain de la défense nationale (DoD) –Hommage à Augusta Ada Byron, comtesse de Lovelace ( ), assistante de Charles Babbage qui travaillait sur sa machine analytique mécanique. Dans un sens très réel, elle est donc le premier programmeur du monde !

12 La compilation Position du problème : –Lordinateur ne comprend que le langage machine –Doù la nécessité de traduire les autres langages en langage machine. Cest le processus de compilation. En 2 phases : –La compilation elle-même qui est la traduction du programme en langage machine –Lédition de liens : qui est lajout des éventuelles librairies pour former au final lexécutable (le.exe sous windows)

13 Entrée / Sortie de Données

14 Les variables Définition : –Une variable correspond à un emplacement précis de la mémoire En ADA, les variables ont : –Un identificateur : un nom –Un type : entier, nombre réel, chaîne de caractères,… –Une valeur : le contenu de la case Exemple : I:Integer:=2; –Déclaration dune variable I de type integer (entier) et dont la valeur est 2.

15 Les variables Mémoire centrale Lordinateur choisit une case mémoire pour stocker notre variable. Le langage ADA fait que lon peut référencer la variable via son identificateur : I I

16 Les variables En ADA, il faut déclarer une variable avant de pouvoir sen servir. Le choix de lidentificateur doit respecter certaines règles : –Uniquement des lettres majuscules/minuscules, –Le trait bas –Les chiffres de 0 à 9 –Et il faut commencer par une lettre. Exemple : « Surface :Float; » Attention, lADA ne fait pas de distinction entre les majuscules et les minuscules. On dit quil est insensible à la casse.

17 Les variables Les identificateurs suivants sont corrects : –X1 –Variable_X_12 Les identificateurs suivants sont incorrects : –12x (on commence par un chiffre) –Revenu&recette (un caractère non permis dans lidentificateur : le « & »)

18 Les variables Deux types essentiels : –Les entiers : Integer en ADA, pour stocker des variables qui sont par nature entières. (un nombre dobjets, un compteur,…) –Les flottants : Float en ADA, pour stocker des nombres réels. (les coordonnées x et y dun point, le résultat dune division,…) Remarque n°1 : il est possible de déclarer plusieurs variables simultanément, par exemple : « X1,X2 :Integer ; » Remarque n°2 : Les types en ADA possèdent des attributs : –Integer First désigne la plus petite valeur possible du type Integer –Integer Last désigne la plus grande valeur possible du type Integer Attention à la notation des constantes en ADA : –23 est nécessairement un nombre de type Integer –23.0 est nécessairement un nombre de type Float

19 Les variables Les opérateurs classiques sappliquent sur ces types : –Les 4 opérations de base. Attention 3/2 donne 1, mais 3.0/2.0 donne 1.5 car la première opération se fait sur des entiers et la deuxième sur les flottants. –** pour lexponentiation –Abs pour la valeur absolue Exemple : I,J:Integer; K:Integer:=4; … I:=K*4; J:=K*I+78**2;

20 Les variables Opérateurs réservés aux entiers : – rem pour le reste de la division entière. La division euclidienne tronque vers zéro. Cela signifie que la valeur absolue du résultat est toujours la même que celle obtenue en divisant les valeurs absolues des opérandes : 7/3 = 2 donc 7 rem 3 = 1 -7/3 = -2 donc –7 rem 3 = -1 – mod pour le modulo arithmétique usuel. Pour b positif, a mod b est toujours dans lintervalle [0;b-1] et pour b négatif, a mod b est toujours dans lintervalle [b+1;0] 11 mod 5 donnera 1 (- 11) mod 5 donnera 4 11 mod (–5) donnera -4

21 Les variables Opérateurs réservés aux flottants : – sqrt pour la racine carrée : sqrt(4.0) donne 2.0 – cos, sin, tan, log,... Attention à lordre de priorité des opérateurs, ne pas hésiter à utiliser les parenthèses : –2+3*4=14 !

22 Les variables Attention bis : On ne peut pas mélanger différents types dans une opération. Exemple : I,J:Float; K:Integer; …. I:=J*2.0;--OK I:=J*K;--illégal Il faut effectuer une conversion de type, en plaçant le type devant la variable, par exemple : I:=J*Float(K);

23 Laffectation Définition : –Laffectation consiste à donner une valeur à une variable Exemple : –En pseudo-code : I 3 J I+4 –En ADA : I:=3; J:=I+4; –A la fin, I:=3 et J:=7. Conclusion « := » est le symbole daffectation en ADA.

24 Structure général dun programme ADA with Ada.Text_Io; use Ada.Text_Io; procedure Mon_Programme is I:Integer:=3; J,K:Float; begin I:=I+5; K:=3; J:=3*K-7; end Mon_Programme; Déclaration des packages utilisés Déclaration des variables Corps de la procédure

25 Sortie de données La sortie de données à lécran s effectue via linstruction « Put », par exemple : Put(« Bonjour le monde »); Put(45); Put(4.1); Put(I);

26 Put(Integer) Attention, il faut inclure la directive suivante avant de pouvoir utiliser Put avec les Integer : with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; Put possède un argument supplémentaire (qui vaut 8 par défaut), la taille minimale des nombres : Put(4,3); affiche : _ _ 4, mais Put(4,4); affiche : _ _ _ 4.

27 Put(Float) Attention, il faut inclure la directive suivante avant de pouvoir utiliser Put avec les Float : with Ada.Float_Text_Io; use Ada.Float_Text_Io; Put possède 3 arguments supplémentaires : –Put(X,N1,N2,N3); avec : X : le nombre à afficher N1 : le nombre de chiffres avant la virgule N2 : le nombre de chiffres après la virgule N3 : le nombre de chiffres de l exposant

28 Autre commande « New_Line » pour passer à la ligne : New_Line; passe une ligne New_Line(4); passe 4 lignes

29 Entrée de données L entrée de données se fait via linstruction « Get ». Elle sutilise de la même façon que « Put ». Exemple : with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; ….. I:Integer; … Get(I);

30 Autre commande Get pioche dans le tampon clavier les données dont il a besoin et laisse les autres : On tape Get(I) va affecter la valeur 12 à la variable I et le tampon deviendra : Pour palier à ce fonctionnement, il est possible de vider le tampon en utilisant linstruction « Skip_Line »

31 Les structures alternatives

32 Les booléens Définition : –Le type booléen (boolean en ADA) correspond à une variable pouvant prendre uniquement 2 valeurs : VRAI ou FAUX (True ou False). Le nom est en hommage à George Boole qui développa lalgèbre de Boole. Exemple : Test: boolean; ….. Test:=True;

33 Les booléens De nouveaux opérateurs sur les entiers et les flottants : « a = b » prend la valeur True si a est égal à b « a /= b » prend la valeur True si a est différent de b « a > b » prend la valeur True si a est supérieur à b « a >= b » prend la valeur True si a est supérieur ou égal à b Idem pour « < »

34 Les booléens Exemple : Test:Boolean; A,B:Integer; …. A:=3; B:=4; ….. Test:=A<=B;.. A la fin du programme Test prend la valeur True.

35 Les booléens Les opérateurs réservés aux booléens : –« not » lopérateur unitaire qui change True en False –« and » lopérateur binaire : et logique. Le résultat est True uniquement si les 2 opérandes valent True –« or » lopérateur binaire : ou logique. Le résultat est True si lun ou lautre des opérandes vaut True, et False si les 2 opérandes sont False –« xor » lopérateur binaire : ou exclusif. Le résultat est True si lun des 2 opérandes (mais pas les 2) vaut True. On peut aussi le considérer comme lopérateur donnant True uniquement quand les 2 opérandes sont différents.

36 Les booléens Exemple : T1,T2:Boolean:=True; ….. T1:=not T2; (T1 vaut False) T2:=T1 or T2; (T2 vaut True) T2:=T1 and T2; (T2 vaut False) T2:=(2<3) or T1; (T2 vaut True)

37 La structure « if » Définition : –Elle permet au programme de prendre des décisions, par exemple en pseudo-code : A 3 Lire B Si A

38 La structure « if » Le même exemple en ADA : A:=3; Get(B); if A

39 Les différentes formes du « if » La plus simple : if condition then instructions …. end if; Avec un else : if condition then instructions …. else instructions …. end if;

40 Les différentes formes du « if » Avec un ou plusieurs elsif : if cond1 then instructions …. elsif cond2 then instructions …. elsif cond3 then instructions …. …. else instructions …. end if;

41 Les « if » imbriqués Les instructions placés au sein des parties du « if » peuvent être quelconques. On peut par conséquent insérer une deuxième structure « if » à lintérieur de la première, par exemple : if a/=0 then if b**2-4*a*c>0 then instructions …. end if; else instructions …. end if;

42 La structure « case » Celle-ci peut remplacer avantageusement une série de elsif dans certains cas particuliers. case variable is when valeur1 => instructions; …. when valeur2 => null; when valeur3..valeur4 => instructions; …. …. when others => instructions; end case; Explications : –Quand la variable prend la valeur « valeur1 » alors cest uniquement les instructions correspondantes à cette valeur qui sont exécutées. La troisième condition est une plage de valeurs entre valeur3 et valeur4. Enfin, others, correspond au comportement par défaut si aucune condition nest réalisée.

43 Les structures répétitives

44 Linstruction « loop » La forme la plus simple des structures répétitives est linstruction loop, exemple : loop instructions… end loop; Il est possible de sortir de la boucle en utilisant le mot-clé « exit ». Par exemple : loop instructions… if a/=0 then exit; end if; end loop;

45 Linstruction « loop » La structure « if cond then exit...» est si commune quelle possède une notation particulière : « exit when cond ». Ainsi on peut écrire : loop instructions…. exit when cond; instructions…. end loop;

46 Linstruction « while » Si le test a effectuer pour sortir de la boucle doit se faire au début de celle-ci, on peut alors utiliser une construction avec « while », dont voici la syntaxe : while cond loop instructions…. end loop; En pseudo-code, on écrira : Tantque cond instructions… Fin Tantque Remarque : linstruction est répétée tant que la condition est VRAI

47 Linstruction « for » Le nombre de répétitions dune même suite dinstructions est souvent connu. On utilisera dans ce cas une structure « for ». La syntaxe est la suivante : for X in V1..V2 loop instructions…. end loop; Dans cette exemple, la variable X va prendre toutes les valeurs entre V1 et V2 puis la répétition va se terminer. Remarque 1 : Dans ce cas précis, il nest pas nécessaire de déclarer la variable X avant son utilisation.

48 Linstruction « for » Remarque 2 : V1 est obligatoirement inférieur à V2. Si lon veut parcourir la plage de valeurs dans le sens contraire, il faut ajouter « reverse » à lentête : for I in reverse loop Put(I); end loop; Le programme précédent va afficher les nombres de 45 à 14 dans cet ordre. En pseudo-code on écrira : Pour I allant de 45 à 14 Ecrire I Fin Pour

49 Les tableaux Première partie

50 Définition Un tableau est une structure permettant de stocker un ensemble de variables du même type. Par exemple : Supposons la nécessité de stocker les notes dune classe à une épreuve. On déclare alors un tableau de dimension la taille de la classe, puis on y stocke les notes. La note N°4 est

51 Définition en ADA En Ada, un tableau à une dimension se déclare de la façon suivante : Nom_variable : array (V1..V2) of Type ; Où : –Nom_variable est le nom du tableau –V1..V2 la plage de valeurs définissant le tableau –Et enfin Type pour le type des variables contenues dans le tableau.

52 Définition en ADA Ainsi pour un tableau de 10 notes (type flottant) : Mon_Tab : array (1..10) of Float; On accède ensuite aux valeurs via Mon_Tab(i), où i est lindice recherché. Exemple : Mon_Tab : array (1..10) of Float; ….. Mon_Tab(4):=17.0; --on fixe la 4ième valeur à 17 Get(Mon_Tab(8)); --on utilise directement le tableau au sein dun Get Mon_Tab(1):=2.0*Mon_Tab(2); --la 1er note est le double de la 2ième. Mon_Tab(2) sutilise donc exactement comme une variable flottante traditionnelle.

53 Retour sur les attributs Une variable de type tableau possède un certain nombre dattributs, sur lexemple précédent : Mon_Tab : array (1..10) of Float; Mon_TabFirst : contient la borne inférieure pour lindice (ici 1) Mon_TabLast : contient la borne supérieure pour lindice (ici 10) Mon_TabLength : contient le nombre de valeurs pour lindice (ici 10) Mon_TabRange : contient directement la plage Par exemple, laffichage du tableau peut se faire via linstruction suivante : for i in Mon_TabRange loop Put(Mon_Tab(i)); New_line; end loop;

54 Retour sur les attributs Remarque N°1 : lutilisation des attributs permet de simplifier lécriture des programmes. Remarque N°2 : et surtout, elle permet de faire des modifications au sein des programmes rapidement et de façon sûre. Exemple : la modification de la taille du tableau nentraîne pas la réécriture des boucles for si celles-ci sont programmées avec lattribut Range.

55 Les agrégats Les agrégats sont des tableaux constants. Ils servent, par exemple, à linitialisation des tableaux. La syntaxe est la suivante : (1.2, 3.0, 4.7) pour un tableau contenant 3 flottants. Exemple : Mon_Tab : array (1..3) of Float:= (1.2, 3.0, 4.7);

56 Les tableaux à 2 dimensions Il est possible de faire des tableaux de dimension quelconque. La syntaxe pour déclarer un tableau de dimension 2 est la suivante : Nom_variable : array (V1..V2, V3..V4) of Type; Pour déclarer un tableau où la deuxième dimension a la plage V3..V4. Pour accéder aux valeurs on utilise la syntaxe suivante : Mon_Tab(i,j) pour avoir la valeur (i,j) ième valeur. Il est toujours possible dutiliser les attributs, mais il faut les faire suivre du numéro de lindice, par exemple : Mon_Tab(1..10,1..5) of integer; …… For i in Mon_TabRange(1) loop….

57 Les tableaux à 2 dimensions Lagrégat de tableau à 2 dimensions prend une forme emboîtée, par exemple : Tab : array (1..3, 1..2) of Integer :=( (1, 3), (2, 7), (18, 2) );

58 La complexité

59 Notion de complexité Introduction –Par nature, plus un programme a de données à traiter, plus il prend du temps à le faire. –Certains algorithmes se comportent mieux que dautres lorsque le nombre de données à traiter augmente. Exemple –Supposons que pour exécuter une tâche précise sur N objects, lalgorithme A ait besoin de N secondes et lalgorithme B: N**2. Alors si lon triple le nombre dobjects, lalgo A prend 3 fois plus de temps, mais lalgo B prend 9 plus de temps. Lalgo B est donc moins efficace que lalgo A, on dit que sa complexité est supérieure à celle de lalgo A.

60 Notion de complexité Définition –La complexité dun algorithme est la donnée du terme prépondérant dans la fonction donnant le nombre dopérations élémentaires effectuées en fonction du nombre des données à traiter. La notation de Landau –Edmund Landau, Mathématicien Allemand, a mis en place une notation permettant de « comparer » des fonctions entre elles. –1er formulation Soit –2ieme formulation: en plus linfini, avec des fonctions positives

61 Notion de complexité Exemples Remarque 1 : –La notion de grand O permet de donner une borne supérieure pour une fonction donnée. Remarque 2 : –Calculer la complexité dun algorithme revient par conséquent à trouver une fonction simple qui est un grand O de la fonction donnant le nombre dopérations élémentaires effectuées en fonction du nombre de données à traiter

62 Notion de complexité Calculer la complexité des algorithmes suivants : –Exemple 1 : Pour i allant de 1 à N Tab(i) 2*Tab(i) Fin Pour –Exemple 2 Pour i allant de 1 à N S 0 Pour j allant de 1 à N S S+Tab(j) Fin Pour Tab(i) S Fin Pour

63 Notion de complexité Quelques constations : –Un algorithme en O(1) est constant, il ne dépend pas de la quantité dinformations en entrée. –Un algorithme en O(n) est dit linéaire –Un algorithme en O(n**2) a une complexité quadratique –Un algorithme en O(ln(n)) a une complexité logarithmique –Un algorithme en O(n**p) a une complexité polynomiale –Un algorithme en O(2**n) a une complexité exponentielle Quelques remarques : –On peut démontrer que le meilleur algorithme de tri de tableau possède en moyenne une complexité de O(n ln(n)) –Les problèmes NP-complets : toute une classe de problèmes qui sont résolus quavec des algorithmes qui ont une complexité exponentielle. Par exemple le problème du voyageur de commerce.

64 Les tableaux Deuxième partie

65 Les constantes Il est possible lors de la déclaration dune variable dindiquer que cette variable est constante. Sa valeur ne pourra pas changer. Il est par conséquent nécessaire dinitialiser cette variable lors de sa déclaration. Exemple : A : constant Integer:=19; Tab : constant array(1..3) of Integer :=(2,4,8); On va utiliser A ou Tab dans un programme exactement de la même façon quune variable classique, mais il sera impossible de les modifier lors dune affectation.

66 Les tranches Il est possible de manipuler les tableaux par tranche de valeurs. Exemple 1: Mon_Tab(2..5) correspond à un petit tableau contenant les valeurs numérotées de 2 à 5. Exemple 2 : Mon_tab(1..4):=Mon_Tab(5..8); --affecte les valeurs des cases 5 à 8 aux cases 1 à 4. Remarque : Mon_Tab(1..4) est à considérer exactement comme un nouveau tableau de taille 4. Il possède donc des attributs différents de Mon_Tab.

67 Les agrégats II Nous avons vu la déclaration de tableaux « constants » via les agrégats. Il existe une syntaxe particulière pour simplifier lécriture de ces agrégats. Il est possible de spécifier des plages de valeurs pour laffectation des cases, par exemple : Tab : array (1..10) of Integer:=(1..5=>15, 6..10=>23); Ainsi, les cases de 1 à 5 sont initialisées à 15, et les cases de 6 à 10 sont initialisées à 23. Il est également possible dutiliser le mot-clé others, par exemple : Tab : array (1..10) of Integer:=(1=>14, 3=>17, others=>23); pour cet exemple le tableau sera initialisé de la façon suivante : Tab:=(14,23,17,23,23,23,23,23,23,23);

68 Les agrégats II (suite) La même logique sapplique pour les agrégats de tableaux à plusieurs dimensions. Par exemple : Tab:array(1..3,1..3) of Integer:=(1=>(others=>7),others=>(2,3,6)); le tableau sera initialisé de la façon suivante : Tab:=((7,7,7),(2,3,6),(2,3,6));

69 Les types Integer, Float,… sont des types prédéfinis de lADA. Il est possible de créer ses propres types afin daccélérer la déclaration des variables, créer une unité logique, mais également de pouvoir comparer des variables entre elles,…. La syntaxe est la suivante : type Mon_Type is Sa_déclaration; Où : –« Mon_type » est le nom choisi pour le type déclaré –« Sa_déclaration » spécifie le type. Exemple : type Mes_Tab is array(1..20) of Integer; Nous pouvons alors utiliser Mes_Tab pour déclarer des tableaux dentiers de taille 20.

70 Les types (suite) Suite de lexemple : Tab1,Tab2 : Mes_Tab; Tab3 : Mes_Tab; où nous avons déclaré 3 tableaux dentiers de taille 20. Ainsi les 2 déclarations suivantes sont « équivalentes » : Tab1 : Mes_Tab; Tab1 : array(1..20) of Integer; Lutilisation des types ne permet pas seulement de raccourcir les déclarations, mais également de créer un nouveau type, donc des variables de ce type. Il est intéressant de faire cette démarche afin de regrouper tous les objets ayant la même fonction.

71 Les types (suite) Ainsi, si lexemple précédent était : Tab1,Tab2 : Mes_Tab; Tab3 : array (1..20) of Integer; Alors : Tab1:=Tab2; --Est possible Tab1:=Tab3; --Est impossible De même que : Tab1(1..5):=Tab2(3..7); --Est possible Tab1(1..5):=Tab3(3..7); --Est impossible

72 Les types de tableaux « type Mes_Tab is array(1..20) of Integer; » définit un tableau dit contraint car la taille du tableau est fixe (20 entiers). Il est possible de définir des tableaux non contraints, où la taille est spécifiée non pas à la déclaration du type mais à la déclaration de la variable tableau, par exemple : type Mes_Tab is array (Integer range <>) of Float; Tab1 : Mes_Tab(1..20); Tab2 : Mes_Tab(0..29); Remarque 1 : <> peut se traduire par « à compléter » Remarque 2 : Tab1 et Tab2 sont toujours 2 objets du même type, ainsi, il est possible de faire : « Tab1(1..10):=Tab2(11..20); »

73 Les types non contraints Il est possible de généraliser les types non contraints aux tableaux à plusieurs dimensions. Ainsi par exemple un type Matrice pourrait se définir comme suit : type Matrice is array(Integer range <>, Integer range <>) of Float; ADA peut se servir de linitialisation du tableau pour deviner sa taille, il est donc possible de taper : type Mes_Tab is array(Integer range <>) of Float; Tab1 : Mes_Tab:=(1.23,2.0,4.8); Tab1 est alors automatiquement créé comme un tableau de taille 3.

74 La concaténation Définition : la concaténation de tableaux consiste à mettre bout à bout 2 tableaux afin de former un tableau de plus grande taille. Lopérateur de concaténation est le « et commercial » & Exemple : type Mes_Tab is array(Integer range <>) of Float; Tab1 : Mes_Tab := (1.0,2.0); Tab2 : Mes_Tab := (3.0,4.0,5.0); Tab : Mes_Tab(1..5); …. Tab:=Tab1&Tab2; --Tab contient (1.0,2.0,3.0,4.0,5.0) Tab:=(2.0,3.0)&(1.0,4.0,5.0); --Tab (2.0,3.0,1.0,4.0,5.0)

75 Les chaînes de caractères Définition : Une chaîne de caractères est un type servant à stocker des mots ou des phrases en ADA. Syntaxe : Les chaînes de caractères en ADA sont simplement des tableaux de « Character ». Un type non contraint « string » est défini ainsi : type String is array (Integer range <>) of Character; La manipulation des chaînes de caractères se fait donc exactement de le même façon que les tableaux, par exemple on déclare une variable de la façon suivante : Phrase : String (1..20); Ou encore « Phrase(1..5):=Phrase2(3..7); » pour affecter un morceau dune chaîne à une autre.

76 Les chaînes de caractères Les chaînes de caractères étant fréquemment utilisées il existe une syntaxe particulière pour les agrégats : du texte entre guillemets, par exemple : Phrase : String:=« Hello »; --va déclarer une variable Phrase de type String et va linitialiser avec lagrégat tableau (H,e,l,l,o), notation habituelle pour les tableaux. Ces agrégats sutilisent partout où il possible de mettre des agrégats normaux, par exemple : Phrase : String(1..20); …. Phrase(1..5):=« Hello »;

77 Les chaînes de caractères Lopérateur de concaténation sapplique également sur les string. Ainsi il est possible de taper : Phrase:=« Bonjour » & « le monde »; Put, Put_Line sont en fait des procédures qui acceptent en entrée (comme arguments) des variables de type string. On peut par conséquent avoir des instructions comme : Put_Line(Phrase); --avec Phrase une variable String Put_Line(« Hello » & « le monde »); Remarque : Lattribut Image du type Integer et Float fabrique un string avec son argument, par exemple : IntegerImage(X) avec X une variable Integer qui contient la valeur 3 est un string qui contient « 3 ». Conclusion : on peut taper linstruction suivante : Put_Line(« Le résultat est : » & IntegerImage(X));

78 Les chaînes de caractères La saisie des chaînes et laffichage des chaînes de caractères posent un dernier problème, il faut afficher le même nombre de caractères que lon a tapé. On utilise pour cela la procédure Get_Line. Elle sutilise de la façon suivante : Get_Line(Phrase,N); où : Phrase est une variable String qui sera affectée par le texte tapé N est une variable Integer qui sera affectée par la longueur du texte tapé Récapitulatif : lextrait de programme suivant demande à lutilisateur dentrer une phrase, puis il la réaffiche à l écran. Phrase : String(1..20); N:Integer; ….. Get_Line(Phrase,N); Put_Line(« Vous avez tapé » & Phrase(1..N));

79 Les Procédures et les Fonctions

80 Problématique Le raffinement dun algorithme doit se traduire au sein du programme par un découpage des tâches. Un programme est souvent amené à répéter la même suite dinstructions plusieurs fois, il serait intéressant de regrouper ces instructions dans un bloc, et « appeler » ce bloc au sein du programme quand nécessaire. La réponse à ces questions passe par lutilisation des fonctions et des procédures !

81 Les procédures Définition : Une procédure permet de regrouper une suite dinstructions dans un programme ADA. Syntaxe : procedure Ma_Proc is Mes_Variables…. begin Le corps de la procédure…. end Ma_Proc;

82 Les procédures Portée et visibilité : with Ada.Text_Io; use Ada.Text_Io; procedure Mon_Programme is A: Integer; procedure Affiche is B: Integer; begin Get(B); end Affiche; begin Put_Line(« Hello »); Affiche; Get(A); end Mon_Programme; Déclaration des packages utilisés Déclaration des variables pour le programme Mon_Programme Procédure AFFICHE Corps du programme principal

83 Les procédures Règles : Une procédure peut être appelée uniquement après avoir été définie Cette règle sapplique également aux variables Une variable définie au sein dune procédure nest accessible que dans cette procédure. On dit que sa portée est limitée à la procédure. Par contre les variables définies dans la partie déclarative du programme principale sont accessibles pour toutes les procédures. Exemples : La procédure Affiche peut être appelée dans le corps du programme principal mais ne pourra pas être appelée dans une procédure définie avant elle-même. La variable B nexiste quà lintérieur de la procédure Affiche. Ainsi le corps du programme principal na pas accès à B. Par contre la variable A est accessible à tous.

84 Un exemple complet with Ada.Text_Io;use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure exemple1 is A: Integer; procedure Erreur is begin Put_Line(« Vous avez fait une erreur ! »); end Erreur; begin Put_Line(« Saisissez un nombre pair divisible par 9 »); get(A); if A mod 2/=0 then Erreur; elsif A mod 9/=0 then Erreur; else Put_Line(« Ok »); end if; end exemple1;

85 Les paramètres Définition : il est possible de passer des paramètres à la procédure afin de spécifier plus précisément son comportement. Exemple 2 : On va appeler une procédure avec un entier et elle va le réafficher entre crochets. Exemple 3 : On désire réaliser une procédure qui va afficher un tableau de type prédéfini Mes_Tab.

86 Exemple 2 with Ada.Text_Io; use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple2 is procedure Affiche(A : Integer) is begin Put(« [ »); Put(A,1); Put_Line(« ] »); end Affiche; begin Affiche(17); Affiche(23); end Exemple2; Remarquez la syntaxe pour le passage du paramètre

87 Exemple 3 with Ada.Text_Io; use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple3 is type Mes_Tab is array (Integer range <>) of Integer; Tab1 : Mes_Tab(1..10):=(others=>17); Tab2 : Mes_Tab(1..5):=(others=>12); procedure Affiche(Tab : Mes_Tab) is begin for I in TabRange loop Put(« La note »); Put(I,1); Put(« est : »); Put(Tab(I),1); New_Line; end loop; end Affiche; begin Affiche(Tab1); Affiche(Tab2); end Exemple3;

88 Les modes Il est possible de spécifier un mode de passage des paramètres à une procédure. Il existe 3 modes pour les paramètres : –in : Cest le mode par défaut, la procédure connaît la valeur de la variable transmise mais elle ne pourra pas la modifier. –out : La procédure est alors appelée nécessairement avec une variable (et non une constante) pour ce paramètre et tout changement du paramètre affecte cette variable. –in out : Identique au mode out mis a part que le paramètre est initialisé avec la valeur dappel de la variable. Syntaxe : on spécifie le mode juste avant le type du paramètre. Cf exemple.

89 Exemple 4 with Ada.Text_Io; use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple4 is B : Integer:=12; procedure Change(A : out Integer) is begin A:=17; end Change; Begin Put(B); Change(B); Put(B); end Exemple4; Mode « out » pour le paramètre A

90 Exemple 4 (suite) Après lexécution de la procédure Change, la variable B contient 17, si lon avait omis le mode out, ce changement aurait été impossible.

91 Les paramètres (suite) Une procédure peut comporter un nombre quelconque de paramètres tous avec leurs propres modes. Dans ce cas, les différents paramètres sont séparés par des points-virgules Exemple 1 : procedure Ma_proc1(X : in Integer; Ok : out boolean) …. Ici, on définit une procédure avec 2 paramètres. Exemple 2 : procedure Ma_proc2(X,Y : in Integer; Ok : out boolean) …. Ici, on définit une procédure avec 3 paramètres, les 2 premiers ayant le même type/mode, ils sont simplement séparés par une virgule.

92 Les fonctions Définition : une fonction est simplement une procédure qui renvoie elle-même une valeur. Syntaxe : function Ma_Fonction return Son_Type is Mes_Variables…. begin Le corps de la fonction…. end Ma_Fonction; Où : Son_Type est le type renvoyé par la fonction Une fonction peut avoir des paramètres, mais ils sont tous obligatoirement du mode in.

93 Exemple 5 with Ada.Text_Io; use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple5 is B : Integer; function Carre(A : Integer) return Integer is begin return A**2; end Carre; begin B:=Carre(4); Put(B); end Exemple5; Le programme affiche 16 !

94 Les fonctions (suite) Lutilisation du mot clé return à lintérieur du corps de la fonction a 2 utilités : –Spécifier la valeur à retourner –Arrêter la fonction et rendre la main à lappelant. Il est donc possible davoir plusieurs return dans le corps de la fonction, par exemple : ….. if A/=0 then return 12; else return 44; end if; …..

95 La récursivité Définition : Résoudre un problème à laide de la récursivité consiste à utiliser une fonction qui sappelle elle-même. Exemple classique : le calcul de la factorielle. Le principe est lécriture dune fonction qui retourne la factorielle de son argument (paramètre). La récursivité est basée sur la formule : n!=n*(n-1)! La fonction va sutiliser elle-même pour le calcul de (n-1)! et va simplement multiplier le résultat par n. Il ne reste plus quà définir la factorielle de 0 au sein de la fonction.

96 Exemple 6 with Ada.Text_Io; use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple6 is B : Integer; function Factorielle(N : Integer) return Integer is begin if N=0 then return 1; else return N*Factorielle(N-1); end if; end Factorielle; begin Put(Factorielle(4)); end Exemple6;

97 Les articles

98 Définition : créer un article, cest créer un groupe de variables qui ont un sens commun. Exemple : on veut sauvegarder une date au sein dune variable, on crée alors un article « Date » composé de 3 entiers pour enregistrer le jour, le mois et lannée. Syntaxe : –Pour la déclaration, on doit créer un nouveau type de la façon suivante : type Date is record Jour : Integer; Mois : Integer; Annee : Integer; end record;

99 Les articles Syntaxe (suite) : –Et pour la déclaration dune variable, on utilise le format habituel Ma_Date : Date; –Pour accéder au contenu de la variable « Ma_Date », cest-à- dire accéder aux différents champs qui la composent, on utilise le point : Ma_Date.Jour:=14; Ma_Date.Mois:=7; Ma_Date.Annee:=1789; –Ainsi « Ma_Date.Jour » peut être utilisée comme une variable de type Integer quelconque.

100 Exemple 1 with Ada.Text_Io; use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple1 is type Date is record Jour, Mois, Annee : Integer; end record; Ma_Date : Date; begin Put(« Entrer le jour : » ); Get(Ma_Date.Jour); Put(« Entrer le mois : »); Get(Ma_Date.Mois); Put(« Entrer lannée : »); Get(Ma_Date.Annee); Put(« Votre Date est : »); Put(Ma_Date.Jour,1); Put(« / »); Put(Ma_Date.Mois,1); Put(« / »); Put(Ma_Date.Anne,1); New_Line; end Exemple1; Définition du type Déclaration de la variable

101 Les articles Remarque : on constate bien lintérêt de larticle dans lexemple pour son rôle dunité logique englobant dans une seule variable la notion de date. Il devient alors possible de copier des dates, échanger des dates, passer des dates comme arguments à une procédure ou une fonction,…. Deuxième exemple : la procédure suivante va afficher une variable Date passée en argument,…. procedure Affiche(X : Date) is begin Put(X.Jour,1); Put(« / »); Put(X.Mois,1); Put(« / »); Put(X.Anne,1); end Affiche; Ainsi, pour afficher Ma_Date, il suffit de faire dorénavant : Affiche(Ma_Date);

102 Les articles Remarque 1 : il est possible dinitialiser un article avec des articles constants. Par exemple : Ma_Date : Date := (14,7,1789); Ou encore au sein du programme : Ma_Date := (14,7,1789); Remarque 2 : il est également possible de donner des valeurs par défaut aux variables dun article : type Date is record Jour : Integer := 14; Mois : Integer := 7; Anne : Integer :=1789; end record;

103 Les articles Suite des 2 remarques : attention linitialisation et les valeurs par défaut ne donne pas le même résultat : –Avec les valeurs par défaut chaque variable créée sera initialisée automatiquement avec ces valeurs –Quand à linitialisation avec un article constant, cest une initialisation ponctuelle réservée uniquement à la variable concernée. Il est dailleurs possible dinitialiser une variable avec un article constant même si larticle possède des valeurs par défaut. Remarque 3 : puisque « Date » est maintenant un nouveau type, on peut lutiliser partout où lon peut mettre un type. Il est donc possible de faire, par exemple, un tableau de « Date » Mes_Dates : array (1..10) of Date; qui va déclarer un tableau de 10 variables de type « Date ». On accède au « Mois » de la variable 5 par : Mes_Dates(5).Mois:=7;

104 Le type énumératif

105 Les énumérations Définition : il est parfois nécessaire de manipuler des variables pouvant prendre des valeurs parmi un groupe fini fixé, on utilise pour cela le type énumératif. Exemple : on veut définir un type « Couleur » pouvant prendre 3 valeurs : le vert, lorange et le rouge. On va alors créer un type énumératif « Couleur », composé des 3 couleurs possibles (Vert, Orange, Rouge). Syntaxe : en Ada on réalise cela via la déclaration de type : type Couleur is (Vert, Orange, Rouge); on peut ensuite déclarer une variable du type « Couleur » Ma_Couleur : Couleur; puis lutiliser au sein du programme avec des instructions du style : Ma_Couleur:=Orange; --dans une affectation ….. If Ma_Couleur=Rouge then --au sein dun test…. ….

106 Les énumérations Remarque 1 : de nouveau, on crée une unité logique avec la déclaration dune énumération. Nous pouvons manipuler la notion de couleur avec facilité via lutilisation du type « Couleur ». Remarque 2 : « Couleur » est maintenant un nouveau type, nous pouvons par conséquent lutiliser partout à la place dun type quelconque. Par exemple, un tableau de couleur, ou encore au sein dun article. type Rectangle is record largeur, longueur : Integer; C : Couleur; end record;

107 Les énumérations Remarque syntaxique : Tous les types énumératifs possèdent un certain nombre dattributs parmi : –First : qui renvoie la première valeur possible : ici Vert –Last : qui renvoie la dernière valeur possible : ici Rouge –Succ : qui renvoie la valeur située juste après son argument, par exemple : CouleurSucc(Orange) donne Rouge –Pred : la même chose avec le prédécesseur. –Pos : qui renvoie la position dans la liste de son argument, par exemple : CouleurPos(Orange) donne 2. –Val : qui renvoie la valeur à la position de son argument, par exemple : CouleurVal(2) donne Orange. –Enfin, il est possible dutiliser les opérateurs = avec les énumérations, par exemple Vert =Rouge retourne FAUX.

108 Les énumérations Remarque 1 : le type Booleen nest rien dautre quune énumération particulière: type Booleen is (False, True); Remarque 2 : comme tout type il est possible dinitialiser les variables lors de leurs déclarations. Ma_Couleur : Couleur := Vert;

109 La surcharge

110 Définition : la surcharge consiste à donner le même nom à 2 procédures (ou à 2 fonctions), la distinction entre les 2 procédures va se faire sur le type des arguments de la procédure. Exemple : procedure Affiche(X : Integer) is begin Put(X,1); end Affiche; procedure Affiche(X : Float) is begin Put(X,1); end Affiche;

111 La surcharge Exemple (suite) : alors si on a : X: Integer; Y:Float; alors « Affiche(X) » va appeler la première procédure et « Affiche(Y) » la seconde. Remarque 1 : on comprend maintenant pourquoi la procédure « Put » est capable dafficher plusieurs types de variables. En effet il sagit en fait de procédures différentes portant toutes le même nom. Remarque 2 : le cas des fonctions nest pas différent de celui des procédures, la distinction entre 2 fonctions portant le même nom se fait sur les arguments de ces fonctions, et dans certain cas sur le type renvoyé. Attention cependant, le compilateur doit toujours être capable de savoir quelle fonction appeler, dans le cas contraire, on parle dambiguïtés. function Carre(X:Integer) return Integer is …. function Carre(X:integer) return Float is…. Cette surcharge peut-être ambiguë.

112 La surcharge Remarque 3 : la surcharge est très pratique, elle permet de nouveau de créer une unité logique : on peut donner un même nom à une même action mais sur des objets différents. Lexemple le plus évident étant linstruction « Put ». Lexemple suivant est le début du TP N°8 : on désire travailler avec les complexes en ADA. Pour cela on définit un type C pour enregistrer un nombre complexe, puis une série de fonctions/procédures se reportant aux complexes. Lexemple propose une implémentation de la procédure « Put » pour laffichage de ce nouveau type, il est rudimentaire, vous aurez loccasion de laméliorer lors du TP.

113 La surcharge ….. type C is record Re,Im : Float; end; procedure Put(Z : C) is begin Put(Z.Re,1,4,0); Put(« + »); Put(Z.Im,1,4,0); Put(« *i »); end Put; ……. A,B:C; begin …. Put(A); ….. Put(B); ….

114 La surcharge dopérateurs

115 Définition : il est possible avec les langages modernes et avec lADA en particulier de surcharger les opérateurs eux-mêmes afin détendre le champ daction de ces opérateurs. Exemple : Continuons lexemple des complexes vu précédent. On désire maintenant pouvoir taper dans un programme directement le code suivant : …. X,Y,Z : C begin ….. Z:=X+Y; …..

116 La surcharge dopérateurs Le code suivant pose problème puisque lopérateur « + » nest pas défini pour fonctionner avec nos articles « C ». Il faut donc créer une définition de « A+B » avec A et B de type « C ». Pour cela on va surcharger lopérateur « + » de la façon suivante : …. function « + » (X,Y : C) return C is begin return (X.Re+Y.Re,X.Im+Y.Im); end « + »; On remarque que la définition correspond à celle dune fonction classique, mis à part son nom « + », les guillemets faisant parti de la syntaxe.

117 La surcharge dopérateurs Remarque 1 : ceci reste logique avec la notion dopérateur, car finalement laddition peut être vu comme une fonction de RxR R, ….. Remarque 2 : Encore une fois la surcharge dopérateur permet de continuer lunité logique réalisée sur les complexes. Maintenant, il est possible additionner 2 complexes au sein dun programme aussi simplement que 2 entiers. Ce concept peut bien-sûr être étendu à tous les types définis par lutilisateur…. La liste des opérateurs quil est possible de surcharger est la suivante : abs and mod not or rem xor = /= >= + - * / ** &

118 La structure declare

119 Définition : il est possible de déclarer des variables dans le corps dune procédure ou dune fonction. On utilise pour cela une structure declare Syntaxe : declare Déclaration des variables begin Corps de la structure declare end On remarque que la syntaxe est la même que pour une fonction ou une procédure, son utilisation est donc identique. Remarque 2 : lensemble de la structure de declare à end porte également le nom de bloc

120 La structure declare with Ada.Text_Io; use Ada.Text_Io; procedure Exemple1 is function Get_String return String is Tampon : String(1..256); N : Integer; begin Get_Line(Tampon,N); return Tampon(1..N); end Get_String; begin loop Put_Line(« Saisissez une phrase »); declare Texte:String:=Get_String; begin Put_Line(« Vous avez saisi : « & Texte); end; end loop; end Exemple1;

121 La structure declare Lexemple précédent réalise la saisie dune phrase via la fonction Get_String. La variable Texte du programme principale est recréée à chaque passage de la boucle, sa taille nest pas fixe, elle varie avec le texte servant à linitialisation. On remarque également dans cet exemple quil est possible dutiliser des calculs ou des fonctions dans linitialisation dune variable. Lexemple suivant montre lintérêt des blocs avec les tableaux

122 La structure declare with Ada.Text_Io; use Ada.Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple2 is N: Integer; begin Put(« Quelle taille pour le tableau : »); Get(N); declare Tab : array(1..N) of Integer; begin for i in Tabrange loop Get(Tab(I)); end loop; ….. end; end Exemple2;

123 La structure declare On voit sur lexemple quil est possible de déclarer le tableau après avoir saisi sa taille et ainsi utiliser exactement le bon nombre de cases en mémoire. Les avantages étant : –Il ny a pas de gaspillage de mémoire –Et surtout lutilisateur nest pas restreint à un choix arbitraire de taille fixée lors de lécriture du programme. (taille fixée à 50 dans les 1er TPs)

124 Les paquetages

125 Définition : les paquetages (packages en anglais) facilitent lécriture de grands programmes : –En découpant le code source en plusieurs fichiers plus petits donc plus lisibles. –En regroupant par unité logique toutes les fonctions/procédures/types ayant un sens commun. Exemple : reprenons le type complexe défini dans les diapos précédentes. Une fois toutes les fonctions/procédures relatives aux complexes écrites, on comprend lutilité de les regrouper dans un paquet. Ceci fait, il est possible pour chaque programme désirant travailler avec les complexes de spécifier dans len-tête lutilisation du paquet complexe.

126 Syntaxe Lécriture dun paquetage se fait en 2 étapes : –La première consiste à créer un fichier de spécification dextension « ads » (s pour spécification), fichier qui va contenir la description du paquet pour les futurs programmes désirant utiliser notre paquetage. –La deuxième consiste à écrire un fichier dextension « adb » (b pour body) qui contient notre paquetage proprement dit. Lexemple suivant illustre le concept par la création dun paquetage « Politesse » contenant 2 procédures.

127 Exemple1 Le fichier politesse.ads : package Politesse is procedure Bonjour (Qui : String); procedure Formule_Fin; end Politesse; Le fichier politesse.adb : package body Politesse is procedure Bonjour(Qui : String) is begin Put_Line(« Cher Monsieur »&Qui); end Bonjour; procedure Formule_Fin is Put_Line(« Veuillez accepter mes salutations bla bla bla…. »); end Formule_Fin; end Politesse;

128 Exemple 1 (Suite) Un exemple de programme utilisant notre paquetage : with Ada.Text_Io; use Ada.Text_Io; with Politesse; use Politesse; procedure Exemple1 is begin Bonjour(« Henri »); Put_Line(« Ramène le CD-ROM,…. »); Formule_Fin; end Exemple1; La compilation de « Exemple1 » se fait comme dhabitude : « gnatmake exemple1 », le compilateur va automatiquement voir quil y a un paquetage utilisé et vérifier son contenu.

129 With/Use Avant de pouvoir utiliser un paquetage dans un programme, il est nécessaire de le préciser avec « with Mon_Paquet ». Le mot-clé « use » a une autre utilité, il permet dutiliser les procédures/fonctions/… du paquet sans devoir préciser le nom du paquetage devant chaque procédures/fonctions/… Lexemple suivant reprend le programme Exemple1 précédent, mais sans la ligne « use Politesse ». Remarquez alors les changements dans le reste du programme.

130 Exemple2 with Ada.Text_Io; use Ada.Text_Io; with Politesse; procedure Exemple2 is begin Politesse.Bonjour(« Henri »); Put_Line(« Ramène le CD-ROM,…. »); Politesse.Formule_Fin; end Exemple2; Comme vous pouvez le constater il est nécessaire de spécifier « Politesse. » devant chaque objet du package afin de pouvoir lutiliser. On va utiliser cette possibilité dans les cas où plusieurs objets sont susceptibles de porter le même nom.

131 E/S fichiers

132 Introduction But : On veut pouvoir lire et écrire des fichiers textes ou de données à partir dun programme ADA. Mise en œuvre : lADA fournit plusieurs techniques permettant de réaliser cette tâche. Ces différentes techniques correspondent à des niveaux dabstractions différents (du plus simple au plus compliqué). On va voir 2 techniques différentes : –Une première générique, afin de lire/écrire dans des fichiers des données quelconques, avec le package Sequential_Io –Une deuxième technique utilisant le package Ada.Text_Io, plus simple, mais ne permettant de lire uniquement que des fichiers textes.

133 Sequential_Io Sequential_Io est un paquet particulier car cest un paquet générique. La généricité permet lécriture en une seule fois de paquets quasi-identiques, paquets qui différent uniquement par exemple sur un type de variable manipulée. (cf les vecteurs, les piles, les conteneurs en général, …) Il est nécessaire par conséquent dinstancier le paquet en spécifiant en argument « la variable » utilisée. Par exemple, si on veut lire/écrire des Integer dans un fichier, on commence par créer un nouveau paquet de cette façon: package Lecture_Integer is new Sequential_Io(Integer); Une fois créé ce paquet sutilise comme les autres, par exemple avec un use, même si pour ce paquet ce nest pas conseillé.

134 Sequential_Io Une fois créé le paquet Lecture_Integer possède les fonctions/procédures/types suivants : –File_Type : type a instancier pour manipuler les fichiers –File_Mode : énumération pour spécifier le type daccès désiré (In_File pour lire, Out_file pour écrire, Append_File pour ajouter à la fin) –Les procédures Create(…) et Open(…) pour créer ou ouvrir un fichier –Read(…) et Write(…) pour lire et écrire dans le fichier. –La fonction End_Of_File(File: in File_Type) return Boolean qui renvoie VRAI si la fin du fichier est atteinte. –… cf John Barnes

135 Exemple with Sequential_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; procedure Exemple is package Lecture_Integer is new Sequential_Io(Integer); use Lecture_Integer; Mon_Fichier:File_Type; Valeur:Integer; begin Open(Mon_Fichier,In_File, « fichier.dat »); while not End_Of_File(Mon_Fichier) loop Read(Mon_Fichier,Valeur); Put(Valeur,1); New_Line; end loop; Close(Mon_Fichier); end Exemple;

136 Ada.Text_Io Outre les fonctions Put_Line, … le package Ada.Text_Io contient les procédures/fonctions/types suivants : File_Type : pour manipuler des fichiers textes File_Mode: qui prend également les valeurs In_File, Out_file ou Append_File procedure Create(File: in out File_Type;Mode in File_Mode:=Out_File; Name: in String:=« »; Form: in String:=« ») pour créer un fichier de nom name sur le HD. procedure Open(… idem create …) pour ouvrir un fichier procedure Close(File: in out File_Type) procedure Get(File: in out File_Type; Item: out Character) qui va lire le prochain caractère dans le fichier et le stocker dans Item procedure Put(File: in out File_Type;Item: in Character) qui va écrire le caractère dans le fichier « File »

137 Ada.Text_Io Lexemple qui va suivre va ouvrir un fichier « texte.txt » supposé dans le répertoire courant puis va afficher les 10 premiers caractères du fichier à lécran. (Le fichier est donc supposé assez grand). Puis ferme laccès au fichier.

138 Ada.Text_Io with Ada.Text_Io; use Ada.text_Io; procedure Exemple2 is Mon_Fichier:File_Type; Mon_Caractere:Character; begin Open(Mon_Fichier,In_Type, « texte.txt »); for I in loop Get(Mon_Fichier,Mon_Caractere); Put(Mon_Caractere); end loop; Close(Mon_Fichier); end Exemple2;

139 Ada.Command_Line

140 Ce package permet aux programmes ADA daccéder aux arguments de la ligne de commande qui a servi à invoquer le programme. Exemple : quand on tape «emacs exemple.adb» –emacs est le nom du programme à exécuter et –exemple.adb est son argument.

141 Ada.Command_Line Pour accéder aux arguments ce package contient (entre autres) les 3 fonctions suivantes: function Argument_Count return Natural; qui renvoie le nombre darguments situés sur la ligne de commande. function Argument(Number: in Positive) return String; qui renvoie largument numéro Number function Command_Name return String; qui renvoie le nom du programme lancé. Lexemple suivant affiche tous les arguments situés sur la ligne de commande. Donc si ce programme est appelé avec « essai riri fifi loulou », il va afficher riri, fifi et loulou.

142 Ada.Command_Line with Ada.Text_Io; use Ada.Text_Io; with Ada.Command_Line; use Ada.Command_Line; procedure Essai is begin for i in 1..Argument_Count loop Put_Line(Argument(i)); end loop; end Essai;

143 Le traitement des exceptions

144 Exception Définition : lorsque le programme se trouve dans une situation quil ne sait pas gérer une erreur durant lexécution dun programme ou alors pour gérer un cas exceptionnel Le programme va récupérer, ou générer, une exception pour que cette erreur soit : 1.Prise en compte 2.Interprétée 3.Gérée

145 Exemple with Ada.Text_io; use Ada.Text_io; with Ada.Integer_Text_io; use Ada.Integer_Text_io; with Ada.Float_Text_io; use Ada.Float_Text_io; procedure Erreur is Val:Integer range 1..9; begin Put("Entrer une valeur : "); Get(Val); New_Line; Put(Val,2); New_Line; end Erreur;

146 Exemple Cas dutilisation normal : Entrer une valeur : 1 La valeur saisie est : 1 Premier cas derreur : Entrer une valeur : Toto raised ADA.IO_EXCEPTIONS.DATA_ERROR Deuxième cas derreur : Entrer une valeur : 12 raised CONSTRAINT_ERROR

147 Exception Les évènements qui déclenchent des exceptions sont: –end_of_file –queue_overflow –divise_by_zero –storage_overflow –…

148 Exceptions prédéfinies Constraint_Error (Numeric_Error) : qui correspond généralement à un dépassement des bornes, ce qui inclut le cas des problèmes en arithmétique tel que la division par zéro; Program_Error : qui apparaît si nous tentons de violer dune certaine façon la structure de contrôle, comme lorsquon atteint un end dans une fonction, lorsque lon viole les règles daccessibilité ou quon appelle un sous-programme dont le corps na pas encore été élaboré; Storage_Error : qui apparaîtra en cas de dépassement mémoire, par exemple, en cas dappel de la fonction récursive Factorielle avec un paramètre trop grand; Tasking_Error : qui est levée si une tâche fait appel à une tâche avortée ou est le résultat dun échec de communication entre 2 tâches

149 Cadre de Traite Exception La syntaxe d'un bloc avec une partie traite_d'exception est la suivante: begin Suite_D_Instructions exception Traite_Exception {Traite_Exception} end; Traite_Exception ::= when Choix_D_Exception{ | Choix_D_Exception} => Suite_D_Instruction Choix_D_Exception ::= Nom_D_Exception | [paramètre_de_choix :] others

150 Cadre de Traite Exception Exemple begin -- suite d'instructions exception when Singularité | Numeric_Error => Put ("La matrice est singulière"); when Storage_Error => Put ("Mémoire insuffisante"); when others => Put ("Erreur fatale"); raise Erreur; end;

151 Blocs Ada permet des déclarations locales et le traitement d'exception dans une suite d'instructions par l'intermédiaire des instructions de bloc. La syntaxe est: instruction_bloc ::= [identificateur_de_bloc:] [declare liste_de_déclaration] begin suite_d_instructions exception traite_d_exception {traite_d_exception} end; Les blocs sont utilisés pour optimiser un programme et pour traiter localement les exceptions.

152 Déclaration dexceptions Les exceptions peuvent être déclarées dans la partie déclarative d'un module. La syntaxe est: nom_d_exception : exception;

153 Déclenchement dexceptions Une exception est déclenchée par l'énoncé raise: –raise [nom_d_exception] [with littéral_chaîne]; Exemple : –raise; -- lever lexception courante –raise Une_Exception; –raise Une_Autre_Exception with Un message relié à lexception; La vérification des exceptions prédéfinies peut être supprimée à l'exécution par l'utilisation du pragma SUPPRESS. –pragma Suppress ( Index_Check, Service); –pragma Suppress (Range_Check);

154 Exemple de programme : Lecture dun entier sécurisé with Ada.Text_io; use Ada.Text_io; with Ada.Integer_Text_io; use Ada.Integer_Text_io; procedure Erreur is function Lit_Entier return Integer is Val: Integer range 1..8; begin loop begin Get(Val); exit; exception when DATA_ERROR => Skip_Line; Put("Valeur incorrecte !"); New_Line; Put("Recommencez..."); New_Line; end; end loop; return Val; end Lit_Entier; begin Put(Lit_Entier); end Erreur;

155 Exemple de programme : Lecture dun entier sécurisé Exécution : Entrez une valeur : Toto Valeur incorrecte ! Recommencez... Entrez une valeur : 4 4 Mais : Entrez une valeur : Toto Valeur incorrecte ! Recommencez... Entrez une valeur : 100 raised CONSTRAINT_ERROR On a pas géré le cas où on rentre une valeur plus grande que 8, il faut donc modifier le programme

156 Exemple de programme : Lecture dun entier sécurisé with Ada.Text_io; use Ada.Text_io; with Ada.Integer_Text_io; use Ada.Integer_Text_io; with Ada.Float_Text_io; use Ada.Float_Text_io; procedure Erreur is function Lit_Entier return Integer is Val: Integer range 1..8; begin loop begin Put("Entrez une valeur : "); Get(Val); exit; exception when DATA_ERROR => Skip_Line; Put("Valeur incorrecte !"); New_Line; Put("Recommencez..."); New_Line; when CONSTRAINT_ERROR => Skip_Line; Put("Vous devez entrez une valeur entre 1 et 8 !"); New_Line; Put("Recommencez..."); New_Line; end; end loop; return Val; end Lit_Entier; begin Put(Lit_Entier,1); end Erreur;

157 Exemple de programme : Lecture dun entier sécurisé Exécution Entrez une valeur : -1 Vous devez entrez une valeur entre 1 et 8 ! Recommencez... Entrez une valeur : Toto Valeur incorrecte ! Recommencez... Entrez une valeur : 4 4

158 Exemple de programme : Génération et Gestion dune exception with Ada.Text_io; use Ada.Text_io; with Ada.Integer_Text_io; use Ada.Integer_Text_io; with Ada.Float_Text_io; use Ada.Float_Text_io; procedure Erreur is Temp: Integer; Trop_Chaud : Exception; Limite: Integer := 100; procedure Saisir_Temperature(T: out Integer) is begin Put("Entrez une température : "); Get(T); if T > Limite then raise Trop_Chaud; end if; end Saisir_Temperature; begin declare begin Temp:=0; Saisir_Temperature(Temp); exception when Trop_Chaud => Skip_Line; Put("Erreur, on fixe la valeur à la limite"); New_Line; Temp:=100; end; Put(Temp,1); end Erreur;

159 Exemple de programme : Génération et Gestion dune exception Exécution : –Cas normal Entrez une température : 4 4 –Cas anormal Entrez une température : 120 Erreur, on fixe la valeur à la limite 100

160 Sous-types et Types dérivés

161 Rappels - Définitions A un type T correspond –Un nom –Un ensemble fini de valeurs –Un ensemble d'opérations primitives agissant sur les valeurs Les opérations peuvent être : –Prédéfinies (affectation, égalité, …) –Attributs –Sous-programmes (ayant un paramètre ou un type de retour égal au type T) à condition que T soit déclaré dans un paquetage et que les sous-programmes soient déclarés dans la spécification du même paquetage

162 Rappels - Définitions A chaque instruction, le compilateur vérifie si l'opération, effectuée sur une variable d'un type donné, est permise. Dans le cas contraire, il n'y aura pas compilation du programme Les types prédéfinis (tels que Integer, Float, Character, String) sont déclarés dans le paquetage Standard dont l'importation est automatique (pas de clause with)

163 Règles Chaque entité doit être déclarée : une entité est, soit une variable, soit une constante La déclaration de chaque entité spécifie son type Toute opération sur une entité doit en préserver le type le type d'une entité est invariant durant l'exécution. C'est le type spécifié à la déclaration

164 Sous-types Un sous-type caractérise un ensemble de valeurs provenant d'un type donné Le sous-ensemble est défini à partir d'une contrainte qui prennent des formes différentes selon la nature du type Le sous-type possède toutes les opérations primitives du type dont il est issu

165 Exemple : subtype JourDeMois is Integer range 1..31; Une variable déclarée : jdm : JourDeMois; pourra prendre des valeurs entre 1 et 31 La déclaration et l'affectation suivante est autorisée à condition que la valeur contenue dans i soit bien dans la contrainte de JourDeMois. i : Integer;... jdm := i; -- peut lever une exception de type CONSTRAINT_ERROR

166 Exemple : type Jour is (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche) Il n'est pas toujours nécessaire d'introduire un sous- type pour imposer une contrainte : j : Jour range lundi.. vendredi; -- est possible k :Jour range lundi.. vendredi; -- mais si cette contrainte doit être l :Jour range lundi.. vendredi; -- utilisée plusieurs fois : Il vaut mieux faire : subtype JourOuvrable is Jour range lundi.. vendredi; j, k, l : JourOuvrable;

167 Remarque Un sous-type n'est pas un nouveau type : maintenant : Jour; terme : JourOuvrable; -- maintenant et terme sont compatibles maintenant := terme; -- est une assignation légale.

168 Exemples Construits à partir des caractères : subtype Minuscules is Character range 'a'..'z'; -- sous type

169 Types dérivés But : A partir d'un type explicitement défini, l'utilisateur peut définir un nouveau type par dérivation Exemple : type B is new A; | | | type parent type dérivé

170 Types dérivés Le type dérivé B a : –Les mêmes opérations primitives –Le même ensemble de valeurs –Les mêmes notations –Les mêmes attributs (au sens Ada) que A Mais A et B sont de type différent

171 Exemple procedure essai is TAUX_ECHANGE : constant Integer := 7; TAUX_ECHANGE_WE : constant Integer := 8; -- Ici, les types dérivés se montrent utiles. -- En effet, on ne peut mettre des francs dans des dollars sans une opération de change ! type Franc is new Integer range 0.. Integer'last; -- types dérivés type Dollar is new Integer range 0.. Integer'last; type Jour is (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); subtype JourOuvrable is Jour range lundi.. vendredi; subtype WeekEnd is Jour range samedi.. dimanche; -- sous-types f1, f2, f3 : Franc := 0; d1, d2, d3 : Dollar := 0; jr : Jour; congé : WeekEnd; i : Integer; begin f2 := 100; f1 := f2 + f3; jr := samedi; if jr in lundi.. vendredi then d1 := Dollar (f1) * Dollar(TAUX_ECHANGE); else congé := WeekEnd (jr); d1 := Dollar (f1) * Dollar(TAUX_ECHANGE_WE); end if; end essai;

172 Attention ! Les types dérivés ne sont pas compatibles avec le type origine Linstruction : i := f2; est illégale Les types dérivés montreront toute leur utilité quand on voudra introduire des notions d'encapsulation et d'abstraction de données avec les types privés et les packages

173 Exemple type B is (rouge, vert, bleu, cyan, magenta, jaune); type B is new A; x : A; y : B; function f (x : A) return A is... end f; function f (x : B) return B is... end f; begin x := A'first; -- x := rouge; -- x := f(x); -- aucun problème car résolution des homonymes x := f(rouge); -- x donne le type de la fonction y := f(rouge); par contre : x := y; -- illégal car x et y de type différent x := A(y); y := B(x); -- => conversion explicite x := A(f(y)); end;

174 Exemple Des ambiguïtés peuvent se produire et obligent à qualifier : if f(rouge) = rouge then -- type A ou B ? => if f(rouge) = B'(rouge) ou if f(B'(rouge)) = rouge ou if B'(f(rouge)) = rouge

175 Attention A(f(...)) convertit le résultat dans le type A A'(f(...)) le résultat est déjà de type A

176 Exemple On dispose d'un type numérique quelconque : type Scalaire is...; D'où sont dérivés d'autres types : type Longueur is new Scalaire; type Surface is new Scalaire; x, y : Longueur; s : Surface; On peut écrire : x := 1.5; y := x ; Mais : s := x; est illégal (on ne peut affecter des longueurs à des surfaces) s := s + x; idem

177 Exemple On écrit les fonctions suivantes : function sommeLongueurs (x, y : Longueur) return Longueur; function sommeSurfaces (x, y : Surface) return Surface; On peut définir : function produitLongueurs (x, y : Longueur) return Longueur; qui est peu utile bien que syntaxiquement correct. Il vaut mieux définir : function produitLongueurs (x, y : Longueur) return Surface is begin return (Surface (Scalaire(x) * Scalaire (y))); end produitLongueurs; Ainsi on peut écrire : s := produitLongueurs(x, y);

178 Exemple On peut également obtenir des sous-types dérivés : type Jour is (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); type JourOuvrable is new Jour range lundi.. vendredi; Le nouveau type hérite des propriétés de jour mais toutes les valeurs sont contraintes dans l'intervalle lundi.. vendredi.

179 Exemple j : Jour; k : JourOuvrable; Alors j := mercredi; k := mercredi; -- correct if j < samedi then... if k < samedi then... Mais k := j; -- illégal k := dimanche; -- erreur d'intervalle k := JourOuvrable (j); -- peut lever CONSTRAINT_ERROR mais est autorisé

180 Les IHM et les interfaces graphiques

181 Les IHM Définition : IHM est lacronyme de Interface Homme-Machine et correspond à tous les dispositifs permettant de rendre conviviale la communication Homme-Machine. Nous allons étudier les rudiments de la programmation dune IHM particulière : linterface graphique.

182 Les interfaces graphiques Problématique : La conception dun programme avec interface graphique diffère par rapport à un programme tournant dans une console.

183 Les interfaces graphiques Dans une console : –Le programme pose des questions, lutilisateur y répond cest un déroulement séquentiel Avec une interface graphique –Le programme réagit aux actions de lutilisateur (click sur Fichier, …) cest un gestion événementielle

184 Les interfaces graphiques La conception générale de tout programme gérant une interface graphique est toujours la suivante : Un événement arrive On dispatche lévénement Ouvrir un FichierHelpQuitter Boucle événementielle On attend un événement

185 Les interfaces graphiques Concrètement le programme possède une boucle qui va ressembler à celle-ci : while not quitter loop Mon_Evenement:=Next_Event; case Mon_Evenement.Kind is when Button_Event=> Traitement boutons souris, …. when Key_Event=> Traitement touche appuyée, …. end case; end loop; Remarque : le programme doit nécessairement faire uniquement des tâches rapides pour rendre linterface réactive. Impossible de lancer un gros calcul entre 2 événements. (cf notion de Threads, …)

186 Initiation aux réseaux

187 Introduction Définition : les réseaux informatiques permettent la communication entre des terminaux distants et un site central, entre des ordinateurs, entre des machines terminales telles que des stations de travail avec leurs serveurs,…. Concept : pour transférer une information à un destinataire distant, il faut formater cette information pour la rendre compréhensible, préciser ladresse du destinataire, établir le chemin de transmission...

188 Les unités en informatique Le bit : le bit est la quantité la plus petite dinformation en informatique puisquelle représente 0 ou 1. Loctet (ou byte en anglais) : correspond à un ensemble de 8 bits, par exemple : Cest très souvent la plus petite unité pour adresser la mémoire des ordinateurs. Le mot (ou word en anglais) : correspond à un ensemble de 16 bits soit 2 octets.

189 Cest quoi un kilo ? Comme pour les autres unités il est possible de parler de kilo- octets (abréviation ko), Méga-octets (abréviation Mo), Giga- octets (abréviation Go),…. Mais en informatique, de façon traditionnelle un kilo ne représente pas 1000, mais Dans la même logique le méga vaut 1024*1024,…. Actuellement les notations ne sont pas encore fixées ou pas encore rentrées dans les esprits des informaticiens. Une norme récente fixe le kilo à 1000 pour respecter le S.I., mais elle nest pas toujours utilisée.

190 Le kbit/s et le Mbit/s Les unités de vitesse de transmission principalement utilisées actuellement sont le kbit/s et le Mbit/s, à savoir une vitesse de 1000 bits à la seconde et de 1 millions de bits à la seconde. Exemple : les cartes utilisées pour les réseaux locaux ont une vitesse de 100Mbit/s, donc 100*1000*1000 bits par seconde, soit en divisant par 8, 12.5Mo/s.

191 Catégories de réseaux

192 Bus : liaison entre processeurs, mémoires et entrées-sorties dun ordinateur Structures dinterconnexion : liaison entre plusieurs ordinateurs entre eux (réseaux relativement fermés avec débits très importants : plusieurs centaines de Mbit/s) Réseaux locaux (LAN Local Area Network) : réseau intra-entreprise (objectif : Transport de toutes les informations de lentreprise - Débits de lordre de quelques Mbit/s jusquà quelques centaines de Mbit/s)

193 Catégories de réseaux Réseaux métropolitains (MAN -Metropolitan Area Network) : interconnexion de plusieurs bâtiments situés dans une même ville ou interconnexion de réseaux locaux Réseaux étendus (WAN -Wide Area Network) : transport de données sur des distances à léchelle dun pays - réseau terrestre ou satellite (par exemple, Internet) - exemples : Transpac (filiale France Telecom), RATP, SNCF (fibres optiques sous les voies), Air France (via satellites)

194 Transfert de données Le transfert des données est assuré par la technique appelée commutation de paquets Toutes les informations sont divisées en fragments que lon appelle des paquets et ces paquets sont transportés jusqu'à lautre extrémité du réseau

195 Commutation de paquets : stocker et acheminer Un message de L bits est transmis à travers un lien de R bps en L/R secondes Mais le message entier doit arriver au routeur avant que celui-ci commence à le transmettre par le prochain lien soit à la machine destinatrice, soit au prochain routeur (stocker et acheminer) Doù le délai de transmission, n étant le nombre de routeurs entre la machine émettrice et la machine destinatrice : (n+1)L/R Exemple : L = 10 Mbits, R = 2 Mbps, 2 routeurs délai = 15 secondes L R R R routeur

196 Maintenant, supposons que le message de 10Mbits est coupé en 5000 paquets Chaque paquet fait 2000 bits Sur un lien, il faudra 1ms pour transmettre un paquet Pipelining : chaque lien travaille indépendamment des autres (en parallèle) => 5000ème arrive au 1er routeur en 5s Le délai sera alors réduit de 15s à 5,002s Commutation de paquets : fragmentation des messages R R Rrouteur Temps (ms)

197 Le modèle OSI

198 Couche physique : connexion physique sur le réseau (modulation, câbles, synchrone ou pas,...) Couche liaison : contrôle du flux, qui a pour but de transmettre les données sans erreur Couche réseau : assure la commutation et le routage des paquets entre les nœuds du réseau

199 Le modèle OSI Couche transport : établissement, maintien et rupture des connexions Couche session : établissement dune connexion logique entre deux applications. Elle assure lorganisation et la synchronisation du dialogue Couche présentation : spécifie la syntaxe des données Couche application : fournit les services et interfaces de commutation aux utilisateurs

200 Paquets ENVOI : –Les données transmises par l'application sont segmentées en paquets –Chaque couche ajoute son en-tête de protocole avant de transmettre le paquet à la couche inférieure : encapsulage des paquets RECEPTION : –Chaque couche enlève l'en-tête qui lui est destiné et transmet les données à la couche supérieure

201 Les supports de transmission Il existe différents types de câbles pour connecter les machines dun réseau

202 Paire torsadée Même câble que pour les téléphones Il existe des câbles à 2 ou 4 paires mais aussi des câbles blindés (STP) ou non blindés (UTP) Défini dans la norme 10 base T Solution économique mais limitée Vitesse de transmission de linformation faible Sensible à lenvironnement électromagnétique

203 Câble coaxial Proche du câble qui relie le téléviseur à son antenne Composé dun câble central entouré dun isolant, lui- même recouvert dune tresse métallique, elle-même recouverte dun isolant Connexions à plus grande distance Néanmoins assez coûteux

204 Fibre optique Média véhiculant des impulsions lumineuses (et non pas électromagnétiques) Insensible aux perturbations pouvant affecter les autres supports De très petite taille (0,1mm) La fibre optique permet daller jusquà 15 km avant que linformation ne subisse de graves détériorations Nécessité de restaurer le signal (tous les km pour le câble coaxial) Du point de vue de la sécurité, pas de génération dactivité électromagnétique - pas de piratage par un récepteur radio Défini dans la norme 10Base F

205 Adressage Deux sortes d'adresses pour identifier les machines sur le réseau : –ADRESSE PHYSIQUE : Media Access Control address ( ), appelée Adresse Ethernet car fixée sur la carte Ethernet, codée sur 6 octets par le constructeur et le vendeur Exemple : 8:0:20:ae:6:1f –ADRESSE RESEAU : adresse INTERNET ( ), fournie sur demande au NIC (Network Information Center) codée sur 4 octets, classées hiérarchiquement Exemple :

206 Adressage - les classes Adresse de classe A : –126 réseaux de classes A –adresses de à –16 millions de machines par réseau

207 Adresse de classe B : – réseaux de classes B –adresses de à – machines par réseau Adressage - les classes

208 Adresse de classe C : – réseaux de classes C –adresses de à –254 machines par réseau Adressage - les classes

209 Adresse de classe D : –adresses réservées au multicast –adresses de à –diffusion de musique, d'informations, sans destinataire particulier Adressage - les classes

210 Equipements dinterconnexion Linterconnexion de réseaux peut être locale: les réseaux sont sur le même site géographique. Dans ce cas, un équipement standard ( répéteur, routeur...) suffit à réaliser physiquement la liaison Linterconnexion peut aussi concerner des réseaux distants. Il est alors nécessaire de relier ces réseaux par une liaison téléphonique (modems...)

211 Le protocole TCP/IP TCP/IP est structuré en quatre niveaux : –Linterface réseau (1 et 2 du modèle OSI) –Le routage (3 du modèle OSI) –Le transport (4 et 5 du modèle OSI) –Lapplication (5, 6 et 7 du modèle OSI)

212 Le routage

213 Internet

214 Les adresses FQDN 7 grands domaines : –com (organisations commerciales) –edu (institutions académiques) –org (organisations institutionnelles ou non) –gov (gouvernement américain) –mil (organisations militaires américaines) –net (opérateurs de réseaux) –int (entités internationales) Les autres domaines désignent à laide de deux lettres un pays (fr, uk, jp, ca, be...). Un exemple : Université du littoral :

215 Les adresses URL une adresse URL est une adresse de la forme : service://machine/directory/fichier –http://www.microsoft.com –ftp://www.cern.fr/public/index.html avantage de ce type d'adresse : englobe beaucoup plus d'informations que l'adresse FQDN, puisquelle comprend: l'adresse FQDN, le type de service, l'emplacement sur le serveur, le nom du fichier

216 Les différents types dURL file:///repertoire/fichier.txt : permet d'accéder à un fichier ici fichier.txt, présent sur votre disque : permet d'accéder à un serveur Web, généralement présent sur une autre machine ftp://serveur/repertoire/fichier : permet d'accéder à un serveur ftp, de visualiser l'ensemble des fichiers d'un répertoire et de rapatrier le fichier sur votre disque local …..

217 Notion de ports Après avoir choisi ladresse de la machine cible, on spécifie le port avec lequel on désire entrer en liaison.

218 Notion de ports Certains ports sont réservés :

219 Notion de client / serveur Pour établir une connexion entre 2 machines avec le protocole TCP/IP, les programmes communiquant sur les 2 machines doivent choisir un port et connaître leurs adresses IP. Dans la pratique un programme dune machine A dit serveur, se met à lécoute dun port sur sa machine. Le client (un programme qui sexécute sur une machine B) connaît ladresse de la machine A et le port choisi. Il demande une connexion sur ce port. Une fois la connexion réalisée, les 2 programmes peuvent séchanger des données pour faire ainsi vivre la connexion.

220 Les sockets Définition : les sockets est le système sous linux permettant la mise en place de connexion TCP/IP. Il existe un package Gnat.Sockets qui englobe un certain nombre de procédures/fonction pour mettre en place la liaison. Le serveur définit le port sur lequel il veut écouter, et le client fixe ladresse IP du serveur pour se connecter via le même port. Une fois la liaison initialisée, les 2 programmes séchangent des données aussi facilement que décrire à lécran.

221 Exemple with Ada.Text_Io; use Ada.Text_Io; with Sockets; use Sockets; procedure Serveur is Carac:Character; Ok:Boolean; begin Socket_Init(« localhost »,8000); --Attention pas de vérification !! Socket_Accept; loop Socket_Get(Carac,Ok); exit when not Ok; Put(Carac); end loop; end Serveur;

222 Exemple (suite) with Ada.Text_Io; use Ada.Text_Io; with Sockets; use Sockets; procedure Client is Phrase :String:="Hello world !"; begin Socket_Init(« localhost »,8000); --Attention pas de vérification !! Socket_Connect; for I in Phrase'Range loop Socket_Put(phrase(I)); end loop; end Client;

223 Le projet à voir….


Télécharger ppt "Initiation à Algorithmique et programmation en ADA."

Présentations similaires


Annonces Google