Initiation à Algorithmique et programmation en ADA

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 : Bibliographie : 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

3 L’algorithmique Définition : Exemple :
Un algorithme est une suite d’instructions 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 l’une après l’autre

4 L’algorithmique Il est possible de raffiner l’algorithme afin qu’il 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 l’eau bouillante 2.3 Attendre que le chocolat soit fondu Réaliser un algorithme pour un ordinateur consiste à raffiner suffisamment l’algorithme afin qu’il soit compréhensible pour la machine.

5 Le pseudo-code Définition Exemple :
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 n’est pas fatigué ramer Fin Tantque Remarquez l’indentation Pour rendre le code plus lisible

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

7 Architecture des ordinateurs
Mémoire centrale 2103 75 2102 45 2101 2100 18 2099 254 Unité Centrale Lecture de l’instruction Exécution de l’instruction Mise à jour de la mémoire 1032 Multiplier la valeur de case 2102 par 5 1031 Sauter à l’instruction de la case 1029 1030 Tester si la valeur de la case 2101 est nulle 1029 Incrémenter la valeur de la case 2101 1028 Soustraire 18 à la valeur de la case 2099 Le programme en langage machine, logé en mémoire, est exécuté par le processeur

8 Les différents langages
Ajoutons 5 à la valeur d’une 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 à l’exé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 d’erreurs Inadapté au développement de programmes de grandes tailles, au développement par plusieurs équipes ………

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

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 : En 2 phases :
L’ordinateur ne comprend que le langage machine D’où la nécessité de traduire les autres langages en langage machine. C’est 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 l’ajout des éventuelles librairies pour former au final l’exécutable (le .exe sous windows)

13 Entrée / Sortie de Données

14 Les variables Définition : En ADA, les variables ont :
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 d’une variable I de type integer (entier) et dont la valeur est 2.

15 Les variables I L’ordinateur choisit une case mémoire pour stocker
Mémoire centrale 2103 75 2102 45 2101 2100 2 2099 254 I L’ordinateur choisit une case mémoire pour stocker notre variable. Le langage ADA fait que l’on peut référencer la variable via son identificateur : I

16 Les variables En ADA, il faut déclarer une variable avant de pouvoir s’en servir. Le choix de l’identificateur 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, l’ADA ne fait pas de distinction entre les majuscules et les minuscules. On dit qu’il 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 l’identificateur : le « & »)

18 Les variables Deux types essentiels :
Les entiers : Integer en ADA, pour stocker des variables qui sont par nature entières. (un nombre d’objets, un compteur,…) Les flottants : Float en ADA, pour stocker des nombres réels. (les coordonnées x et y d’un point, le résultat d’une 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 s’appliquent 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 l’exponentiation 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 l’intervalle [0;b-1] et pour b négatif, a mod b est toujours dans l’intervalle [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 à l’ordre 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 L’affectation Définition : Exemple :
L’affectation 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 d’affectation en ADA.

24 Structure général d’un 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 l’instruction « 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 l’instruction « Get ». Elle s’utilise 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 : 28 44 Pour palier à ce fonctionnement, il est possible de vider le tampon en utilisant l’instruction « Skip_Line »

31 Les structures alternatives

32 Les booléens Définition : Exemple :
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 l’algè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 » l’opérateur unitaire qui change True en False « and » l’opérateur binaire : et logique. Le résultat est True uniquement si les 2 opérandes valent True « or » l’opérateur binaire : ou logique. Le résultat est True si l’un ou l’autre des opérandes vaut True, et False si les 2 opérandes sont False « xor » l’opérateur binaire : ou exclusif. Le résultat est True si l’un des 2 opérandes (mais pas les 2) vaut True. On peut aussi le considérer comme l’opé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<B alors Ecrire « A est inférieur à B » Sinon Ecrire « B est inférieur à A » Fin Si

38 La structure « if » Le même exemple en ADA : A:=3; Get(B);
if A<B then Put(« A est inférieur à B »); else Put(« B est inférieur à A »); end if;

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

40 Les différentes formes du « if »
Avec un ou plusieurs elsif : if cond1 then instructions …. elsif cond2 then elsif cond3 then …. else 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 » à l’intérieur de la première, par exemple : if a/=0 then if b**2-4*a*c>0 then instructions …. end if; else

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 c’est 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 n’est réalisée.

43 Les structures répétitives

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

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

46 L’instruction « 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 : l’instruction est répétée tant que la condition est VRAI

47 L’instruction « for » Le nombre de répétitions d’une même suite d’instructions 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 n’est pas nécessaire de déclarer la variable X avant son utilisation.

48 L’instruction « for » Remarque 2 : V1 est obligatoirement inférieur à V2. Si l’on veut parcourir la plage de valeurs dans le sens contraire, il faut ajouter « reverse » à l’entê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 d’une 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 6 1 2 3 4 5 6 7 8 9 10 14 18 15 12 20

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 l’indice recherché. Exemple : ….. Mon_Tab(4):=17.0; --on fixe la 4ième valeur à 17 Get(Mon_Tab(8)); --on utilise directement le tableau au sein d’un Get Mon_Tab(1):=2.0*Mon_Tab(2); --la 1er note est le double de la 2ième. Mon_Tab(2) s’utilise donc exactement comme une variable flottante traditionnelle.

53 Retour sur les attributs
Une variable de type tableau possède un certain nombre d’attributs, sur l’exemple précédent : Mon_Tab : array (1..10) of Float; Mon_Tab’First : contient la borne inférieure pour l’indice (ici 1) Mon_Tab’Last : contient la borne supérieure pour l’indice (ici 10) Mon_Tab’Length : contient le nombre de valeurs pour l’indice (ici 10) Mon_Tab’Range : contient directement la plage 1..10 Par exemple, l’affichage du tableau peut se faire via l’instruction suivante : for i in Mon_Tab’Range loop Put(Mon_Tab(i)); New_line; end loop;

54 Retour sur les attributs
Remarque N°1 : l’utilisation 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 n’entraîne pas la réécriture des boucles for si celles-ci sont programmées avec l’attribut Range.

55 Les agrégats Les agrégats sont des tableaux constants. Ils servent, par exemple, à l’initialisation 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 d’utiliser les attributs, mais il faut les faire suivre du numéro de l’indice, par exemple : Mon_Tab(1..10,1..5) of integer; …… For i in Mon_Tab’Range(1) loop….

57 Les tableaux à 2 dimensions
L’agré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 Exemple
Par nature, plus un programme a de données à traiter, plus il prend du temps à le faire. Certains algorithmes se comportent mieux que d’autres lorsque le nombre de données à traiter augmente. Exemple Supposons que pour exécuter une tâche précise sur N objects, l’algorithme A ait besoin de N secondes et l’algorithme B: N**2. Alors si l’on triple le nombre d’objects, l’algo A prend 3 fois plus de temps, mais l’algo B prend 9 plus de temps. L’algo B est donc moins efficace que l’algo A, on dit que sa complexité est supérieure à celle de l’algo A.

60 Notion de complexité Définition La notation de Landau
La complexité d’un algorithme est la donnée du terme prépondérant dans la fonction donnant le nombre d’opé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 l’infini, avec des fonctions positives

61 Notion de complexité Exemples Remarque 1 : Remarque 2 :
La notion de grand O permet de donner une borne supérieure pour une fonction donnée. Remarque 2 : Calculer la complexité d’un algorithme revient par conséquent à trouver une fonction simple qui est un grand O de la fonction donnant le nombre d’opé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) Tab(i)S

63 Notion de complexité Quelques constations : Quelques remarques :
Un algorithme en O(1) est constant, il ne dépend pas de la quantité d’informations 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 qu’avec 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 d’une variable d’indiquer que cette variable est constante. Sa valeur ne pourra pas changer. Il est par conséquent nécessaire d’initialiser 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 qu’une variable classique, mais il sera impossible de les modifier lors d’une 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 l’affectation des cases, par exemple : Tab : array (1..10) of Integer:=(1..5=>15 , =>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 d’utiliser 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 s’applique 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 l’ADA. Il est possible de créer ses propres types afin d’accé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 d’entiers de taille 20.

70 Les types (suite) Suite de l’exemple : Tab1,Tab2 : Mes_Tab;
où nous avons déclaré 3 tableaux d’entiers de taille 20. Ainsi les 2 déclarations suivantes sont « équivalentes » : Tab1 : Mes_Tab; Tab1 : array(1..20) of Integer; L’utilisation 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 l’exemple 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 l’initialisation 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. L’opé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 d’une 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 l’initialiser avec l’agrégat tableau (‘H’,’e’,’l’,’l’,’o’), notation habituelle pour les tableaux. Ces agrégats s’utilisent 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
L’opérateur de concaténation s’applique é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 : L’attribut Image du type Integer et Float fabrique un string avec son argument, par exemple : Integer’Image(X) avec X une variable Integer qui contient la valeur 3 est un string qui contient « 3 ». Conclusion : on peut taper l’instruction suivante : Put_Line(« Le résultat est : » & Integer’Image(X));

78 Les chaînes de caractères
La saisie des chaînes et l’affichage des chaînes de caractères posent un dernier problème, il faut afficher le même nombre de caractères que l’on a tapé. On utilise pour cela la procédure Get_Line. Elle s’utilise 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 : l’extrait de programme suivant demande à l’utilisateur d’entrer une phrase, puis il la réaffiche à l ’écran. Phrase : String(1..20); N:Integer; ….. Put_Line(« Vous avez tapé » & Phrase(1..N));

79 Les Procédures et les Fonctions

80 Problématique Le raffinement d’un 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 d’instructions 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 l’utilisation des fonctions et des procédures !

81 Les procédures Définition : Une procédure permet de regrouper une suite d’instructions 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;
Déclaration des packages utilisés 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; Put_Line(« Hello »); Affiche; Get(A); end Mon_Programme; Déclaration des variables pour le programme Mon_Programme Procédure AFFICHE Corps du programme principal

83 Les procédures Règles : Exemples :
Une procédure peut être appelée uniquement après avoir été définie Cette règle s’applique également aux variables Une variable définie au sein d’une procédure n’est 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 n’existe qu’à l’intérieur de la procédure Affiche. Ainsi le corps du programme principal n’a 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; Put_Line(« Saisissez un nombre pair divisible par 9 »); get(A); if A mod 2/=0 then Erreur; elsif A mod 9/=0 then 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 pour le passage du paramètre
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; 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 Tab’Range loop Put(« La note »); Put(I,1); Put(« est : »); Put(Tab(I),1); New_Line; end loop; end Affiche; 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 : C’est 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 d’appel de la variable. Syntaxe : on spécifie le mode juste avant le type du paramètre. Cf exemple.

89 Mode « out » pour le paramètre A
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); end Exemple4; Mode « out » pour le paramètre A

90 Exemple 4 (suite) Après l’exécution de la procédure Change, la variable B contient 17, si l’on 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 Le programme affiche 16 ! 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; B:=Carre(4); Put(B); end Exemple5; Le programme affiche 16 !

94 Les fonctions (suite) L’utilisation du mot clé return à l’intérieur du corps de la fonction a 2 utilités : Spécifier la valeur à retourner Arrêter la fonction et rendre la main à l’appelant. Il est donc possible d’avoir 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 à l’aide de la récursivité consiste à utiliser une fonction qui s’appelle elle-même. Exemple classique : le calcul de la factorielle. Le principe est l’écriture d’une 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 s’utiliser 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; Put(Factorielle(4)); end Exemple6;

97 Les articles

98 Les articles Définition : créer un article, c’est créer un groupe de variables qui ont un sens commun. Exemple : on veut sauvegarder une date au sein d’une variable, on crée alors un article « Date » composé de 3 entiers pour enregistrer le jour, le mois et l’anné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 d’une variable, on utilise le format habituel Ma_Date : Date; Pour accéder au contenu de la variable « Ma_Date », c’est-à-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 Déclaration de la variable
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 l’anné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 l’intérêt de l’article dans l’exemple pour son rôle d’unité 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 d’initialiser 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 d’un article : type Date is record Jour : Integer := 14; Mois : Integer := 7; Anne : Integer :=1789; end record;

103 Les articles Suite des 2 remarques : attention l’initialisation 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 à l’initialisation avec un article constant, c’est une initialisation ponctuelle réservée uniquement à la variable concernée. Il est d’ailleurs possible d’initialiser une variable avec un article constant même si l’article possède des valeurs par défaut. Remarque 3 : puisque « Date » est maintenant un nouveau type, on peut l’utiliser partout où l’on 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, l’orange 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 l’utiliser au sein du programme avec des instructions du style : Ma_Couleur:=Orange; --dans une affectation ….. If Ma_Couleur=Rouge then --au sein d’un test…. ….

106 Les énumérations Remarque 1 : de nouveau, on crée une unité logique avec la déclaration d’une énumération. Nous pouvons manipuler la notion de couleur avec facilité via l’utilisation du type « Couleur ». Remarque 2 : « Couleur » est maintenant un nouveau type, nous pouvons par conséquent l’utiliser partout à la place d’un type quelconque. Par exemple, un tableau de couleur, ou encore au sein d’un 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 d’attributs 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 : Couleur’Succ(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 : Couleur’Pos(Orange) donne 2. Val : qui renvoie la valeur à la position de son argument, par exemple : Couleur’Val(2) donne Orange. Enfin, il est possible d’utiliser les opérateurs < > <= >= avec les énumérations, par exemple Vert<Rouge retourne VRAI mais Orange>=Rouge retourne FAUX.

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

109 La surcharge

110 La surcharge 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

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 d’afficher plusieurs types de variables. En effet il s’agit en fait de procédures différentes portant toutes le même nom. Remarque 2 : le cas des fonctions n’est 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 d’ambiguï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. L’exemple le plus évident étant l’instruction « Put ». L’exemple 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. L’exemple propose une implémentation de la procédure « Put » pour l’affichage de ce nouveau type, il est rudimentaire, vous aurez l’occasion de l’amé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; …. Put(A); Put(B);

114 La surcharge d’opérateurs

115 La surcharge d’opérateurs
Définition : il est possible avec les langages modernes et avec l’ADA en particulier de surcharger les opérateurs eux-mêmes afin d’étendre le champ d’action de ces opérateurs. Exemple : Continuons l’exemple 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 d’opérateurs
Le code suivant pose problème puisque l’opérateur « + » n’est 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 l’opé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 d’une fonction classique, mis à part son nom « + », les guillemets faisant parti de la syntaxe.

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

118 La structure declare

119 La structure declare Définition : il est possible de déclarer des variables dans le corps d’une procédure ou d’une 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 : l’ensemble 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; loop Put_Line(« Saisissez une phrase »); declare Texte:String:=Get_String; Put_Line(« Vous avez saisi : « & Texte); end; end loop; end Exemple1;

121 La structure declare L’exemple précédent réalise la saisie d’une phrase via la fonction Get_String. La variable Texte du programme principale est recréée à chaque passage de la boucle, sa taille n’est pas fixe, elle varie avec le texte servant à l’initialisation. On remarque également dans cet exemple qu’il est possible d’utiliser des calculs ou des fonctions dans l’initialisation d’une variable. L’exemple suivant montre l’inté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; for i in Tab’range loop Get(Tab(I)); end loop; ….. end; end Exemple2;

123 La structure declare On voit sur l’exemple qu’il 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 n’y a pas de gaspillage de mémoire Et surtout l’utilisateur n’est 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 Les paquetages 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 l’utilité de les regrouper dans un paquet. Ceci fait, il est possible pour chaque programme désirant travailler avec les complexes de spécifier dans l’en-tête l’utilisation du paquet complexe.

126 Syntaxe L’écriture d’un paquetage se fait en 2 étapes :
La première consiste à créer un fichier de spécification d’extension « 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 d’extension « adb » (b pour body) qui contient notre paquetage proprement dit. L’exemple suivant illustre le concept par la création d’un paquetage « Politesse » contenant 2 procédures.

127 Exemple1 Le fichier politesse.ads : Le fichier politesse.adb :
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;

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 d’habitude : « gnatmake exemple1 », le compilateur va automatiquement voir qu’il 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 d’utiliser les procédures/fonctions/… du paquet sans devoir préciser le nom du paquetage devant chaque procédures/fonctions/… L’exemple 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 l’utiliser. 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 d’un programme ADA. Mise en œuvre : l’ADA fournit plusieurs techniques permettant de réaliser cette tâche. Ces différentes techniques correspondent à des niveaux d’abstractions 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 c’est 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 d’instancier 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 s’utilise comme les autres, par exemple avec un use, même si pour ce paquet ce n’est 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 d’accè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 L’exemple 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 l’accè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 Ada.Command_Line Ce package permet aux programmes ADA d’accé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 d’arguments situés sur la ligne de commande. function Argument(Number: in Positive) return String; qui renvoie l’argument numéro Number function Command_Name return String; qui renvoie le nom du programme lancé. L’exemple 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 qu’il ne sait pas gérer une erreur durant l’exécution d’un 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 : Prise en compte Interprétée 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); end Erreur;

146 Exemple Cas d’utilisation normal : Entrer une valeur : 1
La valeur saisie est : 1 Premier cas d’erreur : Entrer une valeur : Toto raised ADA.IO_EXCEPTIONS.DATA_ERROR Deuxième cas d’erreur : 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 d’une certaine façon la structure de contrôle, comme lorsqu’on atteint un end dans une fonction, lorsque l’on viole les règles d’accessibilité ou qu’on appelle un sous-programme dont le corps n’a pas encore été élaboré; Storage_Error : qui apparaîtra en cas de dépassement mémoire, par exemple, en cas d’appel 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 d’un é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 d’exceptions
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 d’exceptions
Une exception est déclenchée par l'énoncé raise: raise [nom_d_exception] [with littéral_chaîne]; Exemple : raise; -- lever l’exception courante raise Une_Exception; raise Une_Autre_Exception with “Un message relié à l’exception”; 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 d’un 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 Get(Val); exit; exception when DATA_ERROR => Skip_Line; Put("Valeur incorrecte !"); New_Line; Put("Recommencez..."); end; end loop; return Val; end Lit_Entier; begin Put(Lit_Entier); end Erreur;

155 Exemple de programme : Lecture d’un entier sécurisé
Exécution : Entrez une valeur : Toto Valeur incorrecte ! Recommencez... Entrez une valeur : 4 4 Mais : 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 d’un 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 Put("Entrez une valeur : "); Get(Val); exit; exception when DATA_ERROR => Skip_Line; Put("Valeur incorrecte !"); New_Line; Put("Recommencez..."); when CONSTRAINT_ERROR => Skip_Line; Put("Vous devez entrez une valeur entre 1 et 8 !"); New_Line; Put("Recommencez..."); end; end loop; return Val; end Lit_Entier; begin Put(Lit_Entier,1); end Erreur;

157 Exemple de programme : Lecture d’un 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 ! Entrez une valeur : 4 4

158 Exemple de programme : Génération et Gestion d’une 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 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 d’une 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 : Mais A et B sont de type différent
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 L’instruction : 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 Alors Mais j : Jour; k : JourOuvrable; 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 l’acronyme 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 d’une IHM particulière : l’interface graphique.

182 Les interfaces graphiques
Problématique : La conception d’un 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, l’utilisateur y répond c’est un déroulement séquentiel Avec une interface graphique Le programme réagit aux actions de l’utilisateur (click sur Fichier, …) c’est 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 Boucle événementielle On attend un événement Ouvrir un Fichier Help Quitter

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 l’interface 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 l’adresse du destinataire, établir le chemin de transmission ...

188 Les unités en informatique
Le bit : le bit est la quantité la plus petite d’information en informatique puisqu’elle représente 0 ou 1. L’octet (ou byte en anglais) : correspond à un ensemble de 8 bits, par exemple : C’est 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 C’est 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 n’est 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 Catégories de réseaux Bus : liaison entre processeurs, mémoires et entrées-sorties d’un ordinateur Structures d’interconnexion : 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 l’entreprise - Débits de l’ordre 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 d’un 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 l’on appelle des paquets et ces paquets sont transportés jusqu'à l’autre extrémité du réseau

195 Commutation de paquets : stocker et acheminer
L R routeur 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) D’où 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

196 Commutation de paquets : fragmentation des messages
routeur 1 2 3 5000 4999 Temps (ms) 4 5001 5002 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

197 Le modèle OSI

198 Le modèle OSI 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 d’une connexion logique entre deux applications. Elle assure l’organisation 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 : RECEPTION :
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 d’un 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 l’information faible Sensible à l’environnement électromagnétique

203 Câble coaxial Proche du câble qui relie le téléviseur à son antenne
Composé d’un câble central entouré d’un isolant, lui-même recouvert d’une tresse métallique, elle-même recouverte d’un 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 d’aller jusqu’à 15 km avant que l’information 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 d’activité é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 Adressage - les classes
Adresse de classe B : réseaux de classes B adresses de à machines par réseau

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

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

210 Equipements d’interconnexion
L’interconnexion 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 L’interconnexion 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 :
L’interface 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) L’application (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 à l’aide 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 ftp:// avantage de ce type d'adresse : englobe beaucoup plus d'informations que l'adresse FQDN, puisqu‘elle comprend: l'adresse FQDN, le type de service, l'emplacement sur le serveur, le nom du fichier

216 Les différents types d’URL
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 l’adresse 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 d’une machine A dit serveur, se met à l’écoute d’un port sur sa machine. Le client (un programme qui s’exécute sur une machine B) connaît l’adresse 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 l’adresse 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….