Algorithmes et structures de données avancées 6ème cours Patrick Reuter

Ingrédients dalgorithmes Affectation (ex. mois := 6, jours[1] := 31) Condition/Comparaison (ex. mois <= 12) Appel de fonction (ex. writeln(mois)) Structure de contrôle –Branchements conditionnels (multiples) (si.. Alors.. Sinon) –Boucles (tant que..faire, pour.. faire) Bloc dinstructions (begin.. end)

Aujourd'hui TYPES: –tableau 1D –tableau 2D –types énumérés –enregistrements –pointeurs PORTEE : –variables globales –variables locales APPEL DE FONCTIONS –appel par valeur –appel par référence

Déclaration de variables Comme dans un livre de recettes Ingrédients(pour 8-10 personnes) : - 1 kg de couscous roulé - 1 kg de mouton - 1 poignée de pois chiches - 2 oignons secs tomates fraîches ou 1 cuillère. à soupe de concentré de tomate pommes de terre navets carottes courgettes - 1 tranche de courge - 4 cuillères à soupe d'huile - 1/2 cuillère à café de cannelle - 1 pincée de poivre noir - 1/2 cuillère à soupe de piment rouge doux ou de paprika - 1/2 cuillère à soupe de ras-el-hanout - 1 piment rouge sec g de beurre ou 3 cuillères à soupe d'huile - sel Préparation : La veille, mettez les pois chiches dans un bol d'eau. Le jour même, roulez le couscous. Si vous utilisez du couscous roulé et séché, rincez-le à l'eau froide, égouttez-le et laissez- le gonfler pendant 30 mn. Coupez la viande en morceaux. Pelez les oignons et coupez-en 1 en morceaux. Lavez et passez les tomates à la moulinette. Mettez la viande dans une marmite et ajoutez les morceaux d'oignon, les tomates ou le concentré de tomate dilué dans 1 verre d'eau, l'huile, le poivre, le piment, la cannelle et du sel. Faites revenir …..

Déclaration de variables var compteur : integer; var diviseur : single; var c : byte; var precision : double; var nom : string; var masculin : boolean; var jours : array[1..12] of byte; diviseur := 1.1; { Affectation } compteur : = 1; Nom := Gerhard; Nombre entier Nombre à virgule flottante Nombre à virgule flottante avec double précision Chaîne de caractères Tableau TYPE

Déclaration de variables Types prédéfinis –Integer, boolean, single, … Types que lon peut définir soi-même type t_tableau = array[1..12] of byte; var jours : t_tableau; au lieu de var jours : array[1..12] of byte;

Organisation de la mémoire type t_tableau = array[1..12] of byte; var jours : t_tableau; {12 octets} #0 jours[1] # # # jours[index] #(2000+index-1) jours[3] #2002 jours[12] # Occupe de la place successive dans la mémoire jours[2] #

Tableau 2D

Motivation type t_champ =(vide, blanc, noir); type t_ligne = array[1..8] of t_champ; type t_damier = array[1..8] of t_ligne; var damier : t_damier; var i,j : integer; Pour initialiser un damier vide : POUR i = 1 à 8 faire POUR j = 1 à 8 faire damier[i][j] := vide; FIN POUR

Enregistrements

Déclaration de variables Type enregistrement ( structure hétérogène) type t_enregistrement = RECORD nom_de_variable_1:type1; nom_de_variable_2:type2;... nom_de_variable_n:typen; END; var dossier : t_enregistrement; -structure hétérogène, les éléments peuvent être dun type différent -occupe de la place successive dans la mémoire -« random access » = l accès aux différents éléments se fait à coût égal

Type enregistrement ( structure hétérogène) Exemple Déclaration du type type t_date = RECORD an:integer; mois:byte; jour:byte; END; Déclaration dune variable var aujourdhui : t_date; Affectation aujourdhui.jour = 17; aujourdhui.mois = 10; aujourdhui.an = 2006;

Enregistrements Motivation (à ne pas faire !) type t_couleur = (rouge, vert, jaune); var joueurnom : array[1..n] of string; var joueurscore : array[1..n] of integer; var joueurcouleur : array[1..n] of t_couleur; joueurnom[1] := " Martin; joueurscore[1] := 0; joueurcouleur[1] := rouge; joueurnom[2] := " Romain; joueurscore[2] := 0; joueurcouleur[2] := vert; …

Enregistrements Motivation (à faire !) type t_couleur = (rouge, vert, jaune); type t_joueur = RECORD nom : string; score : integer; couleur : t_couleur; END; var joueur : array[1..n] of t_joueur; joueur[1].nom := " Martin; joueur[1].score := 0; joueur[1].couleur := rouge; joueur[2].nom := " Romain; joueur[2].score := 0; joueur[2].couleur := vert; …

type t_date = RECORD an:integer; mois:byte; jour:byte; END; var aujourdhui : t_date; aujourdhui.an # # # aujourdhui.an; # aujourdhui.an; # #0 Occupe de la place successive dans la mémoire aujourdhui.an; #4003 aujourdhui.mois; #4004 aujourdhui.jour; #

Type tableaux denregistrements Déclaration du type enregistrement : type t_chanson = RECORD titre:string[100]; artiste:string[100]; album:string[100]; longueur:integer; date:t_date; END; Déclaration du type tableau type t_tableau_chansons = array[1..n] of t_chanson; Déclaration dune variable de ce type var collection : t_tableau_chansons; Affectation collection[1].title = Riders on the storm; collection[1].artiste = The Doors;... collection[n].title = Talkin Blues;...

Type tableaux denregistrements Exercice type t_chanson = RECORD titre:string[100]; artiste:string[100]; album:string[100]; longueur:integer; date:t_date; END; type t_tableau_chansons = array[1..n] of t_chanson; var collection : t_tableau_chansons; Trouver lartiste dune chanson donnée kaya i := 1; tant que i<=n i := i + 1; fin tant que

Type tableaux denregistrements Exercice type t_chanson = RECORD titre:string[100]; artiste:string[100]; album:string[100]; longueur:integer; date:t_date; END; type t_tableau_chansons = array[1..n] of t_chanson; var collection : t_tableau_chansons; Trouver lartiste dune chanson donnée kaya i := 1; tant que i<=n si collection[i].title = kaya alors afficher collection[i].artiste; i := i + 1; fin tant que

Type tableaux denregistrements Exercice type t_chanson = RECORD titre:string[100]; artiste:string[100]; album:string[100]; longueur:integer; date:t_date; END; type t_tableau_chansons = array[1..n] of t_chanson; var collection : t_tableau_chansons; Trouver lartiste dune chanson donnée kaya trouve := FAUX; i := 1; tant que (i<=n ET trouve = FAUX) si collection[i].title = kaya alors afficher collection[i].artiste; trouve := VRAI; i := i + 1; fin tant que

NOUVEAU : Addressage mémoire

Adresse dune variable Stocké dans 4 Octets (32 bit), comme ça on peut adresser 2 32 octets = octes = 4 GO Limite bientôt atteint

Organisation de la mémoire var a : byte; ( 1 octet (byte) ) #0 #1 #2 #3 a #4 #5... # # #

Organisation de la mémoire var a : byte; a := 97; #0 #1 #2 #3 a #4 #5... # # #

Organisation de la mémoire var a : byte; a := 97; #0 #1 #2 #3 a #4 #5... # # # Comment connaître ladresse de a ? Addr(a)

Organisation de la mémoire var a : byte; a := 97; p_a := Addr(a);{ Sauvegarder ladresse } #0 #1 #2 #3 a #4 #5... # # # Comment connaître ladresse de a ? Addr(a)

var a : byte; var p_a : ^byte; {4 octets, lire : pointeur vers a} a := 97; p_a := Addr(a);{ Sauvegarder ladresse } #0 #1 #2 #3 #4 a #5... # # p_a # Comment connaître ladresse de a ? Addr(a) p_a #1.001 p_a #1.002 p_a # « p_a pointe vers a »

var a : byte; var p_a : pointer to byte; {4 octets, lire : pointeur vers a} a := 97; p_a := Addr(a);{ Sauvegarder ladresse } { p_a est 4, p_a^ est 97) p_a^ := 10;{ Déréférencement } { p_a est 4, p_a^ est 10) #0 #1 #2 #3 p_a^a #4 #5... # # p_a # Comment connaître ladresse de a ? Addr(a) p_a #1.001 p_a #1.002 p_a #

var a : byte; var p_a : ^byte; {4 octets, lire : pointeur vers a} a := 97; p_a := Addr(a);{ Sauvegarder ladresse } p_a^ := 10;{ affectation par déréférencement } a := 10;{ affectation }

var a : byte; var p_a : ^byte; {4 octets, lire : pointeur vers a} a := 97; p_a := Addr(a);{ Sauvegarder ladresse } p_a^ := 10;{ affectation par déréférencement } a := 10;{ affectation } Cest équivalent !!

Définitions Déclaration dun pointeur vers un byte var p_a: ^byte; Déréférencement dun pointeur : p_a^ Connaître ladresse dune variable a Addr(a); {ou bien

Fonctions

type t_tableau = array[1..n] of integer; var tab : t_tableau; function dedans(quoi : integer, n : integer) : integer; var position : integer; var i : integer; début position := 0; i := 1; tant que (i<=n) faire si (quoi = tab[i]) alors position := i; fin si i := i + 1; fin tant que result := position; fin

type t_tableau = array[1..n] of integer; var tab : t_tableau; function dedans(quoi : integer, n : integer) : integer; var position : integer; var i : integer; début position := 0; i := 1; tant que (i<=n) faire si (quoi = tab[i]) alors position := i; fin si i := i + 1; fin tant que result := position; fin En-tête de la fonction

type t_tableau = array[1..n] of integer; var tab : t_tableau; function dedans(quoi : integer, n : integer) : integer; var position : integer; var i : integer; début position := 0; i := 1; tant que (i<=n) faire si (quoi = tab[i]) alors position := i; fin si i := i + 1; fin tant que result := position; fin Corps de la fonction

type t_tableau = array[1..n] of integer; var tab : t_tableau; function dedans(quoi : integer, n : integer) : integer; var position : integer; var i : integer; début position := 0; i := 1; tant que (i<=n) faire si (quoi = tab[i]) alors position :=i; fin si i := i + 1; fin tant que result := position; fin Paramètres de la fonction (arguments)

type t_tableau = array[1..n] of integer; var tab : t_tableau; function dedans(quoi : integer, n : integer) : integer; var position : integer; var i : integer; début position := 0; i := 1; tant que (i<=n) faire si (quoi = tab[i]) alors position := i; fin si i := i + 1; fin tant que result := position; fin Type de retour de la fonction Valeur de retour de la fonction

La portée :

program portee; var i : byte; function somme(n : byte) : byte; var i : byte; begin result := 0; for i := 1 to n do begin result := result + i; end; begin i:=3; WriteLn(somme(5)); WriteLn('i : ', i); readln; end.

program portee; var i : byte; function somme(n : byte) : byte; var i : byte; begin result := 0; for i := 1 to n do begin result := result + i; end; begin i:=3; WriteLn(somme(5)); WriteLn('i : ', i); readln; end.... #0 i #100

program portee; var i : byte; function somme(n : byte) : byte; var i : byte; begin result := 0; for i := 1 to n do begin result := result + i; end; begin i:=3; WriteLn(somme(5)); WriteLn('i : ', i); readln; end #0 i #100 n #200 i #201 5

program portee; var i : byte; function somme(n : byte) : byte; var i : byte; begin result := 0; for i := 1 to n do begin result := result + i; end; begin i:=3; WriteLn(somme(5)); WriteLn('i : ', i); readln; end #0 i #100 n #200 i #201 5

program portee; var i : byte; function somme(n : byte) : byte; var i : byte; begin result := 0; for i := 1 to n do begin result := result + i; end; begin i:=3; WriteLn(somme(5)); WriteLn('i : ', i); readln; end #0 i #100 n #200 i #

program portee; var i : byte; { Variable globale } function somme(n : byte) : byte; var i : byte; { Variable locale } begin result := 0; for i := 1 to n do begin result := result + i; end; begin i:=3; WriteLn(somme(5)); WriteLn('i : ', i); readln; end.

program portee; var i : byte; { Variable globale } function somme(n : byte) : byte; var i : byte; { Variable locale } begin result := 0; for i := 1 to n do begin result := result + i; end; begin i:=3; WriteLn(somme(5)); WriteLn('i : ', i); readln; end.

Appel des fonctions Appel par valeur Appel par référence

var a : byte; procedure ajouter (parametre : byte) début WriteLn(parametre, parametre); parametre := parametre + 2; WriteLn(parametre, parametre); fin début a := 4; WriteLn(a, a); ajouter(a); WriteLn(a, a); fin Appel par valeur

var a : byte; procedure ajouter (parametre : byte) début WriteLn(parametre, parametre); parametre := parametre + 2; WriteLn(parametre, parametre); fin début a := 4; WriteLn(a, a); ajouter(a); WriteLn(a, a); fin Appel par valeur #0 a #200 #201 #202 # # #203 #220 # #222 #

var a : byte; procedure ajouter (parametre : byte) début WriteLn(parametre, parametre); parametre := parametre + 2; WriteLn(parametre, parametre); fin début a := 4; WriteLn(a, a); ajouter(a); WriteLn(a, a); fin #0 a #200 #201 #202 # # #203 parametre #220 # #222 # Appel par valeur

#0 a #200 #201 #202 # # #203 parametre #220 # #222 # Appel par valeur var a : byte; procedure ajouter (parametre : byte) début WriteLn(parametre, parametre); parametre := parametre + 2; WriteLn(parametre, parametre); fin début a := 4; WriteLn(a, a); ajouter(a); WriteLn(a, a); fin

#0 a #200 #201 #202 # # #203 #220 # #222 # Appel par valeur var a : byte; procedure ajouter (parametre : byte) début WriteLn(parametre, parametre); parametre := parametre + 2; WriteLn(parametre, parametre); fin début a := 4; WriteLn(a, a); ajouter(a); WriteLn(a, a); fin

#0 #200 #201 #202 # # #203 #220 # #222 # Appel par valeur var a : byte; procedure ajouter (parametre : byte) début WriteLn(parametre, parametre); parametre := parametre + 2; WriteLn(parametre, parametre); fin début a := 4; WriteLn(a, a); ajouter(a); WriteLn(a, a); fin 4

Appel par référence var a : byte; type t_p_a = ^byte; procedure ajouter (parametre : t_p_a) begin WriteLn('parametre^', parametre^); parametre^ := parametre^ + 2; WriteLn('parametre^', parametre^); end; début a := 4; WriteLn('a', a); ajouter(Addr(a)); WriteLn('a', a); fin

var a : byte; type t_p_a = ^byte; procedure ajouter (parametre : t_p_a) begin WriteLn('parametre^', parametre^); parametre^ := parametre^ + 2; WriteLn('parametre^', parametre^); end; début a := 4; WriteLn('a', a); ajouter(Addr(a)); WriteLn('a', a); fin Appel par référence Parametre est un pointeur Appel par référence

#0 a #200 #201 #202 # # # Appel par référence var a : byte; type t_p_a = ^byte; procedure ajouter (parametre : t_p_a); begin WriteLn('parametre^', parametre^); parametre^ := parametre^ + 2; WriteLn('parametre^', parametre^); end; début a := 4; WriteLn('a', a); ajouter(Addr(a)); WriteLn('a', a); fin

var a : byte; type t_p_a = ^byte; procedure ajouter (parametre : t_p_a); begin WriteLn('parametre^', parametre^); parametre^ := parametre^ + 2; WriteLn('parametre^', parametre^); end; début a := 4; WriteLn('a', a); ajouter(Addr(a)); WriteLn('a', a); fin #0 a #200 #201 #202 # # #203 parametre #240 parametre # parametre #242 parametre # Appel par référence

#0 a #200 #201 #202 # # #203 parametre #240 parametre # parametre #242 parametre # Appel par référence var a : byte; type t_p_a = ^byte; procedure ajouter (parametre : t_p_a); begin WriteLn('parametre^', parametre^); parametre^ := parametre^ + 2; WriteLn('parametre^', parametre^); end; début a := 4; WriteLn('a', a); ajouter(Addr(a)); WriteLn('a', a); fin

#0 a #200 #201 #202 # # #203 #240 # #242 # Appel par référence var a : byte; type t_p_a = ^byte; procedure ajouter (parametre : t_p_a); begin WriteLn('parametre^', parametre^); parametre^ := parametre^ + 2; WriteLn('parametre^', parametre^); end; début a := 4; WriteLn('a', a); ajouter(Addr(a)); WriteLn('a', a); fin

Appel par référence (2) var a : byte; procedure ajouter (var parametre : byte) début WriteLn(parametre, parametre); parametre := parametre + 2; WriteLn(parametre, parametre); fin début a := 4; WriteLn(a, a); ajouter(a); WriteLn(a, a); fin Une autre façon dappeler une fonction par référence qui est moins explicite