Vous êtes sur la page 1sur 21

Algorithmique et structures de

données
Chapitre 3: Les types de données abstraits (TDA)
Principes du TDA
 Se placer à un niveau d'abstraction élevé
 éviter les erreurs de conception
 Programmer avec des opérations de haut niveau
 qui ne dépendent pas de la représentation interne
 qui permettent de changer de représentation
 Encapsuler les données
 n'accéder à la représentation interne que via des fonctions
 l'utilisateur ne voit que les services (l’interface) pas la représentation
interne
Définition
 Un ensemble de données organisé pour que les spécifications des
objets et des opérations sur ces objets soient séparées de la
représentation interne des objets et de la mise en œuvre des
opérations.

 Pour cela on a besoin de créer une liste de fichiers


 Un fichier pour la définition de la structure
 Un fichier pour citer les opérations possibles à effectuer sur la
structure
 Un fichier pour l’implémentation des opérations selon le types de
structures choisi.
Utilisation d’un TDA
 Se fait exclusivement par l’intermédiaire des
opérations qui leur sont associées et
indépendamment de son implémentation

 En-têtes des fonctions et procédures du TDA :


interface entre l’utilisateur et le TDA
 Manipulation du TDA sans connaître son implémentation
 Utilisation indépendante vis-à-vis de tout changement
d’implantation
Schéma Général
Ce fichier va
préciser sur quel
ELTSDD.h TDA on va travailler
ou
Ce fichier va contenir la
définition du TDA include
Ce fichier contient les primitives
ELTPRIM.h (les signatures) des fonctions
qu’on va appliquer sur notre type
entiers …
de données

ELTINT.h ….

ELTINT.c ….
Ce fichier contient les
implémentation des signatures
des fonctions selon le type choisi.
Types de données
 TD simple ou élémentaire ou primitif (entier,
booléen,…) : chaque variable de ce type peut
prendre une seule valeur du domaine à la fois
 TD composé ou structuré (ou de référence en
java) (tableau, enregistrement…): permet le stockage
sous un même nom de variable de plusieurs valeurs
de même type (exemple tableau d’entiers) ou non
(exemple: type enregistrement)
Structures de Données

TD simples TD composés

TD individuels TD collectifs = SD

Exemple: Enregistrements Exemple: liste, tableau, pile, file,


arbres …

7
TDA ELEMENT: ELTPRIM.h
/***************************************************
* Fichier : ELTPRIM.H
* Contenu : Déclaration des primitives du TDA ELEMENT.
***************************************************/

#ifndef _ELTPRIM_H
#define _ELTPRIM_H

#include "ELTSDD.H"

/* Lecture d'un élément*/


void elementLire(ELEMENT *);

/* Affichage d'un élément/


void elementAfficher(ELEMENT);

/* Affectation du 2eme argument dans le 1er qui est donc modifié et passé par adresse */
void elementAffecter(ELEMENT*, ELEMENT);
TDA ELEMENT: ELTPRIM.h
/* Copie du contenu du deuxième argument dans le premier, les deux arguments
ont des adresses différentes (duplication)*/
void elementCopier(ELEMENT *, ELEMENT) ;

/* Comparaison des arguments retourne un entier 0, < 0 ou > 0 la "différence"


(e1-e2) */
int elementComparer(ELEMENT, ELEMENT);

/* Création d'un élément*/


ELEMENT elementCreer(void) ;

/* Libération de mémoire */
void elementDetruire (ELEMENT);

#endif
Stockage direct vs. indirect
 On va considérer deux exemples (un TDA entier, un TDA
client.
 On distingue les éléments à stockage
 Direct: Un conteneur en stockage direct est propriétaire
des objets qu’il contient cad ses objets sont alloués et
libérés de façon automatique en même temps que le
conteneur.

e Valeur
Stockage direct vs. indirect
 Indirect: Un conteneur en stockage indirect n’est pas
propriétaire des objets qu’il contient i.e. il n’est pas
responsable de l’allocation/libération des objets pointés. En C,
c’est la responsabilité du programmeur de libérer la mémoire
allouée dynamiquement.

e @ Valeur
TDA ELEMENT: ELTINT.h
 Ce fichier contient la définition de l’élément entier:

/***************************************************
* Fichier : ELTINT.H
* Contenu : Déclaration de la structure de données adoptée
* pour une réalisation du TDA ELEMENT.
***************************************************/

#ifndef _ELTINT_H
#define _ELTINT_H

typedef int ELEMENT;

#endif
TDA ELEMENT: ELTINT.c
/********************************************************
* Fichier : ELTINT.C
* Contenu : Définition des primitives pour une réalisation par des
entiers du TDA ELEMENT.
********************************************************/
#include <stdio.h>
#include "ELTPRIM.H"
#define ELEMENT_VIDE 32767
void elementLire(ELEMENT * elt) {
printf(« \nun entier svp :") ;
scanf("%d",elt);
}
void elementAfficher(ELEMENT elt) {
printf(" %d ",elt);
}
TDA ELEMENT: ELTINT.c
void elementAffecter(ELEMENT * e1, ELEMENT e2) {
*e1 = e2 ;}

void elementCopier(ELEMENT * e1, ELEMENT e2) {


*e1 = e2 ;}

ELEMENT elementCreer (void) {


return ELEMENT_VIDE ;}

void elementDetruire (ELEMENT elt) {


/* ne fait rien en stockage direct*/ }
TDA ELEMENT: ELTCLT.h
 Ce fichier contient la définition de l’élément client:
/*****************************************************
* Fichier : ELTCLT.H
* Contenu : Déclaration de la structure de données adoptée
* pour une réalisation du TDA ELEMENT par client.
*****************************************************/

#ifndef _ELTCLT_H
#define _ELTCLT_H

typedef struct
{
char nom[20];
char adresse[30];
ELEMENT ici est un
int cin;
} elem, *ELEMENT; pointeur sur une structure

#endif
TDA ELEMENT: ELTCLT.c
/*************************************************
* Fichier : ELTCLT.C
* Contenu : Définition des primitives pour une réalisation par des clients du TDA
ELEMENT.
************************************************/

#include <stdio.h> Ici on utilise malloc et free


#include <stdlib.h> car on est dans le stockage
#include <string.h> indirect (pointeurs)
#include "ELTPRIM.H"

#define ELEMENT_VIDE NULL

ELEMENT elementCreer (void) {


ELEMENT L;
Sizeof(elem) est different
L = (ELEMENT) malloc(sizeof(elem)); de sizeof(ELEMENT))
return L;
}
TDA ELEMENT: ELTCLT.c
void elementDetruire (ELEMENT elt) {
free (elt);
}

void elementLire(ELEMENT* elt) {


char x;
printf(" \nDonnez un nom svp :") ;
fgets((*elt)->nom, 18, stdin);
printf(" \nDonnez une adresse svp :") ;
fgets((*elt)->adresse, 18,stdin);
printf(" \nDonnez le numéro CIN :") ;
scanf("%d",&((*elt)->cin));
x=getchar();
}
void elementAfficher(ELEMENT elt) {
printf(«\nnom = %s , adresse = %s , CIN= %d ",elt->nom, elt->adresse, elt->cin);
}
TDA ELEMENT: ELTCLT.c
void elementAffecter(ELEMENT* e1, ELEMENT e2) {
*e1 = e2 ;
}
e1 @ cl1  e1: contient une adresse d’un client
ali  *e1 est égal à @cl1
@ cl1 adr1  (*e1)->nom est égal à ali
10  (*e1)->adresse est égal à adr1
 (*e1)->cin est égal à 10
 e2: est une adresse d’un client
 e2->nom est égal à hamed
 e2->adresse est égal à adr2
 e2->cin est égal à 20
e2
hamed
e2 adr2
elementAffecter(&e1, e2)
20
TDA ELEMENT: ELTCLT.c

void elementCopier(ELEMENT *e1, ELEMENT e2) {


strcpy((*e1)->nom, e2->nom);
strcpy((*e1)->adresse, e2->adresse);
(*e1)->cin = e2->cin;
}

e1 @ cl1 e1 @ cl1
ali hamed
@ cl1 adr1 @ cl1 adr2
10 20

e2 e2
hamed hamed
adr2 adr2
20 20
TDA ELEMENT: ELTCLT.c

int elementComparer(ELEMENT e1, ELEMENT e2) {


return ((e1->cin) – (e2->cin)) ;
}
TDA ELEMENT: ELTSDD.H
 Afin d’établir le lien entre ELTPRIM.H et les implémentations on
utilise un fichier intermédiaire ELTSDD.H qui va définir le fichier
d’implémentation
 ELTSDD.H sera modifié quand on voudra changer la représentation
adoptée (entier, clients etc.)
/******************************************************
* Fichier : ELTSDD.H
* Contenu : Inclusion du fichier où est déclarée la structure
de données adoptée pour réaliser le TDA ELEMENT.
******************************************************/

#ifndef _ELTSDD_H
#define _ELTSDD_H

#include "ELTCLT.H"

#endif

Vous aimerez peut-être aussi