Chapitre : Matérialisation de la SD pile

LSI 1
 2

LSI 1

Matérialisation d’une SD
Matérialisation de la SD pile
En tant que OA : représentation chaînée
En tant que TDA : représentation chaînée
Evaluation
 3

LSI 1

Principes généraux de la programmation modulaire

 4

LSI 1

Principes généraux : programmation modulaire

• Dès que l’on écrit un programme de taille importante ou destiné à
être utilisé ou maintenu par d’autres, il est indispensable de fixer
un certain nombre de règles de réécriture
▫ Ces règles de réécriture ont pour objectifs de rendre un programme
lisible, portable, réutilisable, facile à maintenir et à
modifier
• Il est important de fractionner le programme en plusieurs fichiers
▫ Pour bénéficier des avantages de la compilation séparée
 5

LSI 1

Principes généraux : programmation modulaire

• Trois principes généraux doivent guider l’écriture d’un programme C
▫ L’abstraction des constantes littérales
 L’utilisation des constantes littérales dans le corps d’une fonction rend les
modifications et la maintenance difficiles
 Les constantes doivent être définies comme des constantes symboliques au
moyen de la directive #define
▫ La factorisation du code
 Son but est d’éviter les duplications de code
 Utilisation des fonctions
▫ La fragmentation du code
 Il est intéressant de découper un programme en plusieurs fichiers
 Pour des raisons de lisibilité et de réutilisabilité
 6

LSI 1

Principes généraux : programmation modulaire

• Une règle d’écriture est d’associer à chaque fichier source nom.c un
fichier entête nom.h qui définit son interface
▫ Le fichier d’entêtes nom.h
 comporte les déclarations des fonctions non locales au fichier nom.c
 Ces fonctions sont appelées fonctions d’interface
 et comporte les définitions des constantes symboliques et des macros qui
sont partagées par les deux fichiers
 doit être inclus par la directive #include dans tous les fichiers qui utilisent
l’une des fonctions du fichier nom.c

Le fichier nom.h doit être inclus dans tous les fichiers qui
font appel à une fonction d’interface définie dans nom.c
 7

LSI 1

Principes généraux : programmation modulaire

• Les fichiers ayant l’extension (.h) comportent
 des déclarations de constantes symboliques, types, variables et sous
programmes (fonctions d’interface)
 des directives au préprocesseur

• Les fichiers ayant l’extension (.c) comportent

 des déclarations de constantes, types, variables, sous programmes
 des réalisations de sous-programmes dont la déclaration se trouve dans le fichier
d’entêtes .h
 des réalisations de fonctions locales
 Un fichier ayant l’extension .c peut ne pas comporter le sous-
programme main
 Un fichier ayant l’extension .c qui ne comporte pas main ne peut pas être
exécuté
 8

LSI 1

Principes généraux : programmation modulaire

• Une phase importante qui intervient après la compilation pour
obtenir un programme exécutable est la phase d’édition de liens
 L’éditeur de liens résout entre autres les références à des appels
dont le code est conservé dans des librairies
 L’éditeur de liens permet également d’assurer la compilation séparée
et de concevoir un programme comme un assemblage de briques (ou
modules)
 Manière statique : à la compilation
▫ le code de chaque fonction sera inséré à l’exécutable
 Manière dynamique : à l’exécution
▫ le code sera chargé lors de l’exécution et les bibliothèques doivent être présentes sur
la machine lors de l’exécution
 9

LSI 1

Principes généraux : programmation modulaire

Algorithme
Chaîne de développement d’un programme
Editeur

Programme source

Compilateur Erreurs de compilation

Editeur de
Erreurs d’édition de liens
liens

Programme cible
Résultat
Données Processeur
Erreurs d’exécution
 10

LSI 1

Principes généraux : programmation modulaire

Source1
interface
Compilation obj1
implémentation

Source2
interface
Compilation obj2 Edition de liens Programme
implémentation exécutable

Sourcen
interface
Compilation objn
implémentation
Un fichier ayant l’extension .c doit comporter
le sous-programme main
 11

LSI 1

Principes généraux
Possibilités fournies par le langage C pour la matérialisation d’un SD
Matérialisation de la SD pile en tant que OA : représentation chaînée
Matérialisation de la SD pile en tant que TDA : représentation chaînée
Evaluation
 12

LSI 1

Principes généraux
• Pour pouvoir concrétiser (matérialiser ou réaliser ou implémenter ou
implanter) une SD on distingue les concepts suivants

▫ Interface
 elle regroupe les opérations (ou les services) définies sur la SD
 Illustration (cas de la SD pile)
▫ creer_pile
▫ vide
▫ dernier
▫ empiler
▫ depiler
 On dit que la SD pile exporte les services cités ci-dessus.

▫ Implémentation
 elle regroupe la réalisation des services exportés par l’interface de la SD
 13

LSI 1

Principes généraux
▫ Utilisation
 elle utilise ou réutilise des services proposés par l’interface. Lors de l’utilisation
on voit la SD Pile via son interface

▫ Assertion
 est une expression de type booléen
 elle est censée être évaluée à vrai lors de son exécution
 dans le cas où l’assertion (affirmation) est violée (évaluée à faux), on arrête
l’exécution
 Le concept d’assertion est utilisé pour protéger la SD des utilisations illégales
 Par exemple : depiler sur une pile vide
 14

LSI 1

Possibilités fournies par le langage C

• Le langage C offre un mécanisme permettant l’évaluation des
assertions
▫ Un tel mécanisme est traduit par la macro-instruction assert de la
librairie assert.h
 Cette macro-instruction possède les caractéristiques suivantes
 Sur le plan syntaxique: assert(expression)
▫ assert est une instruction (ou macro-instruction) utilisée dans la PE d’un sous
programme
▫ expression est une expression valide au sens du langage de programmation C
 Sur le plan sémantique
▫ L’exécution de l’instruction assert entraîne l’évaluation de son expression
▫ Le résultat de cette évaluation conditionne la suite
 15

LSI 1

Possibilités fournies par le langage C

 On distingue deux cas
▫ Cas 1 : résultat ≠ 0 : (expression est satisfaite ou remplie) alors passer à
l’exécution de l’instruction qui suit l’instruction assert
▫ Cas 2 : résultat=0 affirmation est violée ou non respectée alors assert va
entraîner l’arrêt d’une façon brutale l’exécution du programme en signalant une
erreur ayant la forme suivante

Assertion Failed : expression File : nom fichier Line : numéro ligne Abnormal program terminaison
 16

LSI 1

Matérialisation de la SD pile
• La matérialisation de la SD pile peut se faire soit en tant
que
▫ Objet abstrait(OA)un seul exemplaire (ici une seul pile)
unique implicite
▫ Type de Données Abstrait (TDA) plusieurs exemplairesil faut
mentionner ou rendre
explicite l’exemplaire courant
 17

LSI 1

Représentation chaînée

Matérialisation de la SD pile : OA
Partie interface : pile.h
• L’interface pile.h regroupe des services
exportés par cette interface
▫ Chaque service correspond à une
opération applicable sur la SD (ici la SD
Pile)
▫ il est fourni sous forme d’un sous-
programme
• Les opérations applicables sur la SD Pile
▫ Opération de création
 procédure ou fonction
▫ Opérations de modification
 procédures
▫ Opérations de consultation
 fonctions
18
LSI 1
Partie interface : pile.h
/* opération de création */
void ceer_pile(void) ;
/*opérations de consultation*/
unsigned vide (void) ;
/* 1 si la pile est vide sinon 0*/
int dernier (void) ;
/*opérations de modification*/
void empiler (int) ;
/* Le paramètre est la valeur à empiler*/
void depiler(void ) ;
Ainsi, l’interface joue le rôle du guide
d’implémentation vis à vis de la
réalisation
 19

LSI 1

Matérialisation de la SD pile : OA
Partie implémentation : pile.c
/* librairies standards*/
#include <stdio.h> • Remarque
#include <alloc.h>
#include <assert.h> ▫ Les opérations définis dans pile.h
opèrent sur une pile unique à
/* librairie spécifique définie par le programmeur*/
#include ’’pile.h’’ caractère implicite
/* pile.h est censée être stocké dans le répertoire courant appelé
répertoire de travail*/ ▫ La partie implémentation (pile.c)
/*représentation physique*/ réalise les services exportés par
struct element l’interface (pile.h)
{
int cle ; ▫ Celle ci comporte
struct element * suivant ;
};  Les signatures ou le entêtes des services
static struct element *sommet ; exportés
/* Pour restreindre la portée de cette variable à ce fichier, il faut  Et pour chaque opération exportée par
utiliser le mot réservé static on fait la variable sommet n’est
pas destinée à l’exportation */ l’interface sa sémantique(rôle)
 20

LSI 1

Matérialisation de la SD pile : OA
Partie implémentation : pile.c Illustration
void creer pile(void)
{ sommet=NULL ; }
Représentation Abstraite d’une pile vide
unsigned vide(void)
{ return(sommet==NULL) ; }
sommet
int dernier(void)
{ assert( ! vide()) ; Représentation Chaînée d’une pile vide
return(sommet cle) ; @
/* return((*sommet).cle)*/ sommet
cle suivant

}
4
@ 3
@ 2
@ 1
 21

LSI 1

Matérialisation de la SD pile : OA
Partie implémentation : pile.c Illustration
void empiler(int info) @
cle suivant
{ struct element*p ; sommet
p=(struct element*) malloc(size of(struct element)) ;
4
@ 3
@ 2
@ 1


pcle=info;
info
psuivant=sommet; p
/*mettre à jour sommet*/ @
sommet=p; }
@
cle suivant
sommet
4
@ 3
@ 2
@ 1

info
@
 22

LSI 1

Matérialisation de la SD pile : OA
Partie implémentation : pile.c Illustration
void depiler(void) sommet
@
{ struct element*p ; cle suivant

assert( !vide()) ;   4
@ 3
@ 2
@ 1

 p=sommet ; info
@
 sommet= sommet suivant ;
Libérer de la mémoire
free(p) ; }
p @

@
cle suivant
sommet
4
@ 3
@ 2
@ 1
 23

LSI 1

Matérialisation de la SD pile : OA
Partie utilisation : test.c
#include " pile.h "
void main(void)
• La partie utilisation voit la SD (ici la SD
{ pile) uniquement via son interface elle
unsigned i;
creer pile();
utilise les services fournis par l’interface
assert(vide());
for(i=1;i<=10;i++)
{
empiler(i);
}
assert(!vide());
for(i=1;i<=10;i++)
{
printf(“%d\n”,dernier());
dépiler();
}
assert(vide());
}
 24

LSI 1

Représentation chaînée

Matérialisation de la SD pile : TDA
Partie interface : pile.h
• L’interface pile.h regroupe des services exportés
par cette interface
▫ Chaque service correspond à une opération
applicable sur la SD (ici la SD Pile)
▫ il est fourni sous forme d’un sous-programme
• Les opérations applicables sur la SD Pile
▫ Opération de création
 procédure ou fonction
▫ Opérations de modification
 Procédures
 La pile est passée par adresse
 La pile est un paramètre formel de type
entrée/sortie
▫ Opérations de consultation
 Fonctions
 La pile est passée par valeur
 La pile est un paramètre formel de type entrée
25
LSI 1
Partie interface : pile.h
/*représentation physique*/
struct element
{
int cle ;
struct element * suivant ;
};
/* opération de création */
struct element* creer_pile(void) ;
/* void créer pile(struct element* *) */
/*opérations de consultation*/
unsigned vide (struct element*) ;
/* 1 si la pile est vide sinon 0*/
int dernier (struct element*) ;
/*opérations de modification*/
void empiler (int, struct element* *) ;
void depiler(struct element* * ) ;
passage par adresse de la pile
 26

LSI 1

Matérialisation de la SD pile : TDA

Partie implémentation : pile.c Partie implémentation : pile.c
#include <stdio.h>
#include <alloc.h>
void depiler(struct element** p)
#include <assert.h> { struct element*q ;
#include ’’pile.h’’
struct element* creer pile(void) assert( !vide(*p)) ;
{ return NULL ; } q=*p ;
unsigned vide( struct element* p)
{ return(p == NULL) ; } *p= q suivant ;
int dernier(struct element* p)
{ assert( ! vide(p)) ;
free(q) ; }
return(p  cle) ; }
void empiler(int info, struct element* *p)
{ struct element*q ;
q=(struct element*)malloc(size of(struct element)) ; passage par valeur de la pile
qcle=info;
qsuivant=*p; Une pile est définie par son sommet
/*mettre à jour sommet*/ Un sommet est de type struct element *
*p=q; }
 27

LSI 1

Matérialisation de la SD pile : TDA

Partie utilisation : test.c Partie utilisation : test.c
#include<stdio.h> /*affichage de p1 et p2*/
#include « pile.h » for(i=1 ;i<=10 ;i++)
void main(void) {
{ printf(“%d\t%d\n”,dernier(p1),
dernier(p2));
struct element*p1; depiler(&p1);
struct element*p2; depiler(&p2);
unsigned i; }
p1=creer pile(); /* p1 et p2 devraient être vides*/
for(i=1;i<=10;i++) if(vide(p1)&&vide(p2))
empiler(i,&p1); printf(“quelle joie!!”);
p2=creer pile(); else
for(i=11;i<=20;i++) printf(“problème!?!?”);
}
empiler(i,&p2);
 28

LSI 1

Matérialisation de la SD pile : évaluation

• Les possibilités fournies par le langage C vis-à-vis de la
matérialisation d’une SD
▫ Cas de la pile
 Position ou emplacement de la représentation physique
 Paramétrage de la SD par le type des éléments
 Position des assertions
 29

LSI 1

Matérialisation de la SD pile : position ou emplacement de

la représentation physique
Cas de l’OA : 1ère perception Cas du TDA : 2ème perception
• La représentation physique figure dans la partie interface
• La représentation physique figure dans la • Lors de la l’utilisation d’une SD fournie sous forme d’un OA,
partie implémentation on peut manipuler les aspects liés à sa
représentation physique
• Lors de l’utilisation d’une SD fournie sous #include « pile.h »
void main(void)
forme d’un OA, on ne peut pas {
manipuler les aspects liés à sa struct element* p1;
représentation physique unsigned i;
p1=creer_pile(); /* pile */
#include « pile.h » p1=NULL; /* pointeur */
empiler(3,&p1); /* pile */
… p1=(struct element*) malloc(size of(struct
element)) ; /* pointeur */
creer_pile() ; }

La représentation physique est dans la partie

interface et par conséquent on peut manipuler
cette représentation lors de l’utilisation
 30

LSI 1

Matérialisation de la SD pile : position ou emplacement de

la représentation physique
• L’idéal est d’imposer la 1ère perception
▫ Le langage de programmation C offre des moyens permettant la
matérialisation d’une SD sous forme d’un OA
 En mettant la représentation physique dans la partie implémentation en
utilisant la classe d’allocation static
 Qui permet d’interdir l’utilisation de l’OA en dehors du fichier en question
(pile.c)
▫ Par contre, le langage C présente des faiblesses vis-à-vis de la
matérialisation de la SD sous forme de TDA
 En effet, il n’interdit pas la manipulation des aspects liés à la
représentation physique lors de l’utilisation
 31

LSI 1

Matérialisation de la SD pile : paramétrage de la SD par le

type des éléments
• Une SD mémorise un ensemble d’éléments de même type ou de
type conforme (l’héritage dans le cadre OO)
• Les opérations applicables sur une SD ne dépendent pas de la
nature des éléments de cette SD
▫ Le langage C n’offre pas les moyens pour considérer le type des
éléments comme paramètre
 Si la matérialisation s’est faite en considérant le type int et si un nouveau
besoin consiste à considérer float comme type des éléments
 Des changements dans la partie interface et dans la partie implémentation
sont nécessaires
 32

LSI 1

Matérialisation de la SD pile : paramétrage de la SD par le

type des éléments

SD pile ayant un
paramétrage sur le
type des éléments

SD pile des SD pile des

réels entiers

De telles solutions peuvent être réalisées par des LP comme ADA

 33

LSI 1

Matérialisation de la SD pile : position des assertions

• Il y a des opérations sur la SD exigeant des pré-conditions
▫ depiler exige que la SD Pile soit non vide
▫ Dans les deux variantes (OA et TDA) les assertions figurent dans la partie
implémentation car assert est considérée comme une macro-instruction
• Les assertions traduisent des pré-conditions concernant l’usage
(clients) de cette SD
• les assertions font partie intégrante de la sémantique ou signification
de l’opération
▫ Les pré-conditions sont considérées comme des obligations du client
(utilisation) vis-à-vis du fournisseur (ici la SD)
▫ Normalement la place des pré-conditions est l’interface et non la partie
implémentation
En conclusion, le langage C est peu voir même non adapté à la matérialisation des SD