Spécifier une méthode abstraite

C’est :

. identifier une méthode : en-tête,

. préciser son mode d’utilisation : PRE,
. préciser ses effets (son action) : POST,
. préciser les données modifiées : MOD.

 Les spécifications d’une méthode abstraite se font à partir

d’un texte structuré qui contient un en-tête, suivi de trois
clauses PRE, POST, MOD (certaines pouvant être vides).
 Les spécifications textuelles peuvent être sauvegardées
dans un fichier pour aider à une utilisation ultérieure de
cette méthode.
17
Spécifier une méthode abstraite
L’entête (identification)

 On y précise le nom de la méthode (procédure, fonction)

précédé éventuellement du type du résultat retourné et
suivi de la liste (pouvant être vide) des arguments et de
leur type.

Exemples :
(tableau[entier][max]) insérer(tableau[entier][max] T;
entier i,c,n)
(salaireTad) créerSalaire()
trier (tableau[entier][n] T)
18
Spécifier une méthode abstraite
Les clauses : la pré-condition

 On y précise les conditions d’utilisation de la méthode.

 On la note PRE.

Exemples :

(tableau[entier][max]) insérer(tableau[entier][max] T;
entier i,c,n)
PRE : les valeurs de c sont calculées par la fonction
calcul. n est la taille de T. i est une position dans T.

(salaireTad) créerSalaire()
PRE : salaireTad est un type abstrait spécifié ou construit.
19
Spécifier une méthode abstraite
Les clauses : la post-condition

 On y précise les effets de la méthode, ce qu’elle rend en

résultat et/ou l’action qu’elle réalise.
 On la note POST.
Exemples :
(tableau[entier][max]) insérer(tableau[entier][max] T;
entier i,c,n)
PRE : Les valeurs de c sont calculées par la fonction calcul.
n est la taille de T. i est une position dans T.
POST : Insère c dans T en position i et retourne un accès à T.
(salaireTad) créerSalaire()
PRE : salaireTad est un type abstrait spécifié ou construit.
POST : Crée une entité salaire avec une valeur par défaut.
20
Retourne un accès à cette entité.
 Spécifier une méthode abstraite
Les clauses : la clause MOD

 Dans la clause MOD, on précise les arguments modifiés

en cours d’exécution (effets de bord).

Exemple :
(tableau[entier][max]) insérer(tableau[entier][max] T;
entier i,c,n)
PRE : Les valeurs de c sont calculées par la fonction calcul.
n est la taille de T. i est une position dans T.
POST : Insère c dans T en position i. Retourne un accès à T.
MOD : T.
21
Spécifier une méthode abstraite
Les clauses : remarque

 Une clause vide (qui ne contient pas de texte)

peut ne pas figurer dans une spécification.
 Par exemple la procédure :
(salaireTad) créerSalaire()
PRE : salaireTad est un type abstrait spécifié ou construit.
POST : Crée une entité salaire avec une valeur par défaut.
Retourne un accès à cette entité.

ne contient pas de clause MOD.

22
Spécifier une méthode abstraite
Intérêts

 La spécification d’une méthode permet :

. sa clarification
. une construction plus aisée, car une spécification contient des
éléments formels utiles à cette construction ;
. sa vérification : une méthode n’est utilisable que dans les conditions
précisées dans la clause PRE. Son utilisation sous conditions doit
réaliser les actions définies dans la clause POST et ne modifier que les
arguments de la clause MOD.

 Les spécifications sont des documents contractuels en ingéniérie

logicielle

 Une fois spécifiée, une méthode peut être utilisée dans un programme
en langage algorithmique et permet ainsi de retarder, quand cela est
nécessaire, un choix de construction dans un langage algorithmique ou
de mise en œuvre dans un langage de haut niveau.
23
 Exemple

 Cas de la fonction masseSalariale spécifiée

p.16

 Elle peut être utilisée dans tout programme en

langage algorithmique sans pour cela qu’elle
soit réalisée dans un quelconque langage

24
 CANEVAS POUR
SPECIFICATION DE TAD
EN-TETE
SI COLLECTION SI NON COLLECTION
DESC DESC
Éléments de la collection et leur types Caractéristiques des entités et leurs types
(éventuels commentaires) (éventuels commentaires)

OP OP
AVEC PARCOURS SANS PARCOURS Primitives de gestion
créer une instance du type
affecter des valeurs aux caractéristiques
modifier ces valeurs
Primitives pour parcourir accéder à une valeur
initier un parcours, détruire
se positionner, Primitives de gestion
progresser, créer, insérer, choisir,
terminer appartenir, vider,
supprimer un élément,
détruire
25
 Spécifier un type abstrait

C’est :

. Identifier un type et son interface : en-tête,

. Préciser la nature des entités de ce type : DESC,
. Préciser son interface : OP.

- Les spécifications d’un type abstrait (TAD) se font à partir

d’un texte structuré qui contient un en-tête*, suivi de deux
clauses DESC et OP.
- Les spécifications textuelles peuvent être sauvegardées
dans un fichier pour une utilisation ultérieure de ce type.
*Attention : ne pas confondre l’en-tête d’un TAD avec l’en-tête d’une
26
méthode
 Spécifier un type abstrait
L’entête (l’identification)

 On y précise le nom du TAD, suivi de la liste des noms des

méthodes primitives* (l’interface du TAD) permettant d’agir
sur des entités de ce TAD.

Exemples :
salaireTad(créerSalaire, affecterSalaire, modifierSalaire,
accéderSalaire, détruireSalaire) -> Solution 2 pour l’exemple 1 p.6

ensemble[elt](créerEns, insérerEns, choisirEns, appartientEns,

oterEns, videEns, détruireEns)

* Rappel : ces primitives sont à la base de la construction de

toute méthode utilisant des données du TAD.
27
 Spécifier un type abstrait
La clause DESC

 On y précise la nature (les caractéristiques) des entités du

TAD.
Exemples :
salaireTad(créerSalaire, affecterSalaire, modifierSalaire,
accéderSalaire, détruireSalaire)
DESC : Caractéristiques :
charge : de type réel (charge salariale d’une année)
année : de type entier (année correspondant à charge)

ensemble[elt](créerEns, insérerEns, choisirEns, appartientEns,

ôterEns, videEns, détruireEns)
DESC : Toute entité de type ensemble[elt] est une collection
d’éléments de type elt sans redondance.
p.4
28
 Spécifier un type abstrait
La clause OP

 La clause OP contient les spécifications des méthodes

abstraites (opérations primitives) autorisées sur les entités
du TAD.

 Ces primitives sont ainsi supposées être des méthodes

prédéfinies que l’on peut directement utiliser pour
construire d’autres méthodes
(de la même façon que l’on utilise des opérateurs prédéfinis dans un
langage de programmation, voir exemples à partir de la p.36).

29
 Spécifier un type abstrait
Exemple 1 (Solution 2) :
le TAD salaireTAD
salaireTad(créerSalaire, insérerSalaire, modifierSalaire, accéderSalaire)
DESC : Caractéristiques :
charge de type réel (charge salariale d’une année),
année de type entier (année correspondant à charge).
OP :
(salaireTad) créerSalairep()
POST : Crée une entité salaire avec une valeur par défaut.
Retourne un accès à cette entité.
affecterSalairep(salaireTad s; réel s1; entier s2)
PRE : le couple (s1, s2) est une valeur possible de s.
POST : affecte la valeur (s1, s2) à s.
MOD : s
modifierSalairep(salaireTad s; réel/entier v; entier i)
PRE : i = 1 si 1ère composante de s, i = 2 si seconde. v est réel ou entier.
POST : modifie la ième composante de s. La nouvelle valeur est celle de v.
MOD : s.
(réel/entier ) accéderSalairep(salaireTad s; entier i)
PRE : i = 1 si 1ère composante de s, i = 2 si seconde.
POST : retourne la valeur de la ième composante de s (réel ou entier).
30 + détruireSalairep(salaireTad s)
Mise en œuvre d’une abstraction
Exercice (suite solution 2)

Question 1 :
En utilisant le TAD salaireTad de la solution 2 précédente, écrire un
programme en ALGO créant et retournant une entité salaire quand les
valeurs de ses caractéristiques (charge et année) sont données en entrée.

(salaireTad) prog2(réel c; entier a)

Possible
{
en ALGO
salaireTad x ← créerSalairep() // x est initialisé
à partir de
affecterSalairep(x, c, a)
spécifications
retourner(x)
}

Comparer avec le programme de la page 8 basé sur la solution 1.

31
 Mise en œuvre d’une abstraction
Exercice (fin solution 2)

Question 2 :
En supposant qu’il existe une fonction saisie donnant les salaires des
50 dernières années, écrire la fonction (réel) masseSalariale () qui
calcule et retourne la masse salariale des 10 dernières années.

(réel) masseSalariale2() {
inclure saisie // saisie retourne un tableau des salaires
réel s ← 0 // des 50 dernières années
tableau[salaireTad][50] T ← saisie()

pour i de 41 à 50
s ← s + accéderSalairep(T[i], 1)
retourner(s)
}
32
 Autre exemple :
LE TAD GENERIQUE ensemble
ensemble[elt](créerEns,insérerEns,choisirEns,appartientEns,oterEns,videEns)
DESC : Toute entité de type ensemble[elt] est une collection sans doublon d’éléments
de type elt. elt doit être défini ou construit.
OP :
(ensemble[elt]) créerEnsp()
POST : Crée un ensemble d’éléments de type elt initialement vide.
Retourne un accès à cet ensemble.
(ensemble[elt]) insérerEnsp(ensemble[elt] E, elt e)
PRE : La valeur de e n’est pas dans E.
POST : insère la valeur de e dans E et retourne E.
MOD : E
(elt) choisirEnsp(ensemble[elt] E)
PRE : E n’est pas vide.
POST : retourne un élément quelconque de E.
(booléen) appartientEnsp(ensemble[elt] E, elt e)
POST : retourne vrai si e est dans E, faux sinon.
(ensemble[elt]) oterEnsp(ensemble[elt] E, elt e)
PRE : La valeur de e est dans E.
POST : supprime la valeur de e de E et retourne E.
MOD : E
(booléen) videEnsp(ensemble[elt] E)
POST : retourne vrai si E est vide, faux sinon. + détruireEnsp(ensemble[elt] E)
33
 Spécifier un type abstrait
Intérêts

 La spécification d’un TAD permet :

. une construction plus facile de ce type, car la spécification contient
des éléments formels utiles à cette construction (descriptif)
. une aide à la construction de méthodes manipulant des objets du type
(à partir de l’interface du type)
. une plus grande adaptabilité, car au niveau des spécifications
textuelles (non réalisées), toute modification des caractéristiques et/ou
de l’interface, n’a pas de grandes conséquences

 Une fois spécifié :

. un TAD peut être utilisé dans un programme en langage algorithmique
et retarde ainsi, quand cela est nécessaire, un choix de mise en
œuvre dans un langage de haut niveau ou algorithmique
. un TAD peut être ré-utilisé dans un autre contexte (sous les mêmes
spécifications).
34
 EXERCICE

En utilisant les TADs déjà spécifiés (dont le TAD ensemble) :

Question 1 : Ecrire un algorithme permettant de saisir et

stocker dans un ensemble des données correspondant à
la charge salariale annuelle des 10 années à partir de l’an
2000.

Question 2 : Ecrire un algorithme calculant la moyenne de la

charge salariale des 10 années à partir de l’an 2000.

35
 SOLUTION QUESTION 1

ensemble[salaireTad] saisie10()
{
// Voir spécifications TADs
salaireTad s
// salaireTad, ensemble[elt]
entier a ← 2000
réel c
ensemble[salaireTad] E ← créerEnsp()
pour i de 1 à 10
{ s ← créerSalairep()
écrire(“année : “, a, “ charge ? “)
lire(c)
affecterSalairep(s, c, a)
E ← insérerEnsp(E,s)
a ← a+1
}
retourner(E)
}
36
 SOLUTION QUESTION 2

Attention :
(réel) moyenne ()
utiliser le TAD ensemble
{ inclure saisie10
signifie que la collection
salaireTad s manipulée ne contient pas
réel v ← 0 de redondance d’éléments.
ensemble[salaireTad] E ← saisie10()
tant que videEnsp(E) = FAUX
{ Si des redondances de
s ← choisirEnsp(E) valeurs de salaires étaient
constatées, on utiliserait
E ← ôterEnsp(E, s)
plutôt le TAD liste (défini
v ← v + accéderSalairep(s, 1) plus loin dans un exercice).
}
retourner(v/10)
}

37
 EXERCICE

 Donner les spécifications d’une procédure permettant de

supprimer tous les éléments plus grands qu’un élément
donné dans un ensemble.

 Construire cette procédure en langage algorithmique en

utilisant tout TAD déjà défini.
On pourra utiliser la fonction supérieur supposée déjà
définie et dont les spécifications sont les suivantes :
(booléen) supérieur(elt e1; elt e2)
POST : rend vrai si e1 est plus grand que e2 selon une
relation d’ordre sur le type elt.
38
 SOLUTION

Spécification :

partieInf(elt v; ensemble[elt] E)
PRE : Les valeurs de v et E sont connues.
POST : Supprime tous les éléments de E plus
grands que v selon la relation d’ordre sur
le type elt définie dans la fonction supérieur.
MOD : E.
39
 SOLUTION (suite)

Programme en ALGO :
partieInf(elt v, ensemble[elt] E)
{
elt x
ensemble[elt] A ← créerEnsp()
tant que NON(videEnsp(E))
{
x ← choisirEnsp(E)
E ← ôterEnsp(E, x)
si NON(supérieur(x, v))
A ← insérerEnsp(A,x)
}
E←A
40
}
 EXERCICE

1. Donner les spécifications d’une fonction

permettant de compter le nombre d’éléments d’un
ensemble, puis la construire en ALGO en utilisant
le TAD ensemble.

1. Donner les spécifications d’une fonction

permettant de recopier les éléments d’un
ensemble dans un tableau (on a ainsi un ordre sur les
éléments correspondant aux positions du tableau), puis la
construire en ALGO en utilisant le TAD ensemble.

41
 1 – Fonction compter
SPECIFICATIONS :
(entier) compter (ensemble[elt] E)
POST : Compte et retourne le nombre d’éléments de E.
MOD : E peut être vidé s’il n’est pas sauvegardé.

PROGRAMME EN ALGO :
(entier) compter (ensemble[elt] E)
{ ensemble[elt] A ← créerEnsp()
A←E // A permet une sauvegarde de E
entier compte ← 0
elt x
tant que videEnsp(A) = FAUX
{ x ← choisirEnsp(A)
compte ← compte+1
A ← ôterEnsp(A, x) }
retourner(compte) }
42
 2 – Fonction transférer
SPECIFICATIONS :
(tableau[elt][n]) transférer(ensemble[elt] E)
PRE : n est plus grand ou égal au nombre d’éléments dans E.
Utiliser la fonction compter avant de fixer la taille d’un tableau T déclaré localement.
POST : Insère les éléments de E dans T et retourne T.
MOD : E peut être vidé s’il n’est pas sauvegardé.

PROGRAMME EN ALGO :
(tableau[elt][n]) transférer (ensemble[elt] E)
{ tableau[elt][n] T // n est plus grand ou égal au nombre d’éléments de E
elt x
entier i ← 1
tant que (videEnsp(E) = FAUX) et (i ≤ n)
{ x ← choisirEnsp(E)
T[i] ← x
i←i+1
E ← ôterEnsp(E, x) }
retourner(T)
} 43 // E est vide à la fin car on a choisi de ne pas sauvegarder E
 CANEVAS POUR
SPECIFICATION DE TAD
EN-TETE
SI COLLECTION SI NON COLLECTION
DESC DESC
Éléments de la collection et leur types Caractéristiques des entités et leurs types
(éventuels commentaires) (éventuels commentaires)

OP OP
AVEC PARCOURS SANS PARCOURS Primitives de gestion
créer une instance du type
affecter des valeurs aux caractéristiques
modifier ces valeurs
Primitives pour parcourir accéder à une valeur
initier un parcours, détruire
se positionner, Primitives de gestion
progresser, créer, insérer, choisir,
terminer appartenir, vider,
supprimer un élément Diapositive 25
détruire
44
 REMARQUE

 Les langages orientés objet permettent de

représenter des entités d’un TAD sous forme
d’objets en utilisant la notion de « type objet »
(ou classe) dont une définition textuelle
reprend l’essentiel de celle de TAD.

45
 TAD et approche objet

Spécifications d’un TAD Spécifications d’une classe

- On précise le nom du TAD - On précise le nom de la classe

et son interface et son interface

- On donne un descriptif du - On donne les responsabilités

TAD (clause DESC) de la classe et les attributs
des objets de la classe

- On donne les spécifications - On définit les en-têtes des

des opérations primitives méthodes

- Liens hiérarchiques possibles - Liens d’héritage entre classes

entre entités de types différents

46