Terminale, Spécialité Numérique et Sciences Informatiques

Types abstraits de données

Abstract Data Type - ADT

1 Présentation des types abstraits de données

1.1 Dénition
Un Type abstrait de données (TAD) est un ensemble de données
organisé, et d'opérations sur ces données.
Un type abstrait de données est un ensemble de données - dont on ne précise par la représentation concrète
- doté d'un ensemble d'opérations, dont on précise seulement les spécications. On fait donc à la fois abstraction
de la manière dont les données sont représentées et de la manière dont les opérations sont programmées.
Le concept de type abstrait n'est pas lié à un langage de programmation particulier. Il peut être mis
en oeuvre via des mécanismes de programmation, dont en particulier la programmation objet, la programmation
modulaire ou la programmation avec des fonctions.

1.2 Un peu de vocabulaire

Un type abstrait de données se dénit par ses primitives. Les primitives sont simplement les fonctions
essentielles s'appliquant à notre structure.
Parmi les primitives d'un type abstrait on distingue :
I les constructeurs, qui permettent de créer des données,
I les sélecteurs, qui permettent d'accéder à tout ou partie de l'information contenue dans une donnée,
I les opérateurs, qui permettent d'opérer entre données du type (opération internes) ou avec d'autres types
de données (opérations externes),
I les prédicats, qui permettent de tester une propriété.
L'ensemble des fonctionnalités disponibles pour un type de données en constitue l'interface - la partie
visible pour qui veut utiliser ce type de données.
L'implémentation consiste à concrétiser - réaliser eectivement - un type de données en dénissant la
représentation des données avec des types de données existant, et en écrivant les programmes des opérations.

2 Quelques exemples
2.1 Un premier exemple : le type Rationnel
On peut dénir un type abstrait Rationnel, en dénissant l'ensemble de ses valeurs possibles par référence
à l'ensemble des rationnels en mathématiques Q et en proposant l'interface suivante :
I Constructeur : fait_rationnel : (entier,entier) → rationnel
I Sélecteurs :
. numérateur : rationnel → entier
. dénominateur : rationnel → entier
I Opérateur : + : (rationnel,rationnel) → rationnel
I Prédicat : égal : (rationnel,rationnel) → booléen
Le programmeur utilisant ce type de données doit pouvoir écrire :
egal(fait_rationnel(1,2) + faitrationnel(1,6), fait_rationnel(2,3))

2.3 Structures de données Page 1/3

J.Devalette
 Terminale, Spécialité Numérique et Sciences Informatiques
Il obtiendra un résultat correct, sans se soucier de la manière dont les diérents traitements sont program-
més. Il peut faire abstraction de la représentation et du détail des calculs, et ne se soucie donc pas du moment où
peut être eectuée ou non la simplication d'un rationnel.

2.2 Un second exemple : le type Date

Nous allons proposer la spécication d'un type abstrait Date, permettant de construire des dates en heures
et minute d'avoir des sélecteurs pour chaque élément, de calculer une durée en minutes, de comparer deux dates.
Voyons voir deux implémentations simpliées possibles :
Implementation 1 Implementation 2

I constructeur : I constructeur :
. fait_date . fait_date

(entier1,entier2) → Date (entier) → Date

I sélecteurs I sélecteurs
. heure . heure

Date → entier1 Date//60 → entier

. minute . minute

Date → entier2 Date%60 → entier

I Opérateur : I Opérateur :
. duree . duree

(Date,Date) → entier (Date,Date) → entier

I Prédicat : I Prédicat :
. egal . egal

(Date,Date) → Booléen (Date,Date) → Booléen

En observant les spécications des deux implémentations proposées on peut se rendre compte que les choix
des programmeurs ne sont pas forcément les mêmes.
Le premier a décidé d'implémenter Date comme 2 entiers où le premier représente les heures le second les
minutes. Les sélecteurs seront donc simples à implémenter, mais l'opérateur duree demandera certainement un
calcul.
Le second a décidé d'implémenter Date comme un seul entier qui représente les minutes, les sélecteurs
demande donc un calcul, alors que l'opérateur duree ne sera qu'une simple diérence.
Dans tous les cas, la spécication du type abstrait décrit le type de données et donc l'utilisateur se contente
de l'interface pour utiliser le type Date sans se préoccuper de savoir comment sont implémenter les primitives
correspondant au type de données.

3 Implémentation du type Date

3.1 Implémentation n°1
Nous allons commencer par réaliser un exemple d'implémentation fonctionnelle de notre Type Abstrait de
Données, ce n'est pas une procédure habituelle, en tout cas en langage python, mais elle a le mérite d'être simple.
Nous aborderons plus tard dans l'année, dans la partie Programmation Orientée Objet, une méthode plus propre
d'implémentation de types de données.
# contructeur # se lect eurs
def f a i t _ d a t e ( h ,m) :
def heure ( date ) :
# operateur
return h ,m def duree ( date1 , date2 ) :
return date [ 0 ]
h = date2 [ 0 ] − date1 [ 0 ]
#pré dicat def minute ( date ) :
m = date2 [ 1 ] − date1 [ 1 ]
def e g a l ( date1 , date2 ) : return h * 60+m
return date [ 1 ]
return date1==date2

2.3 Structures de données Page 2/3

J.Devalette
 Terminale, Spécialité Numérique et Sciences Informatiques
3.2 Implémentation n°1 : compléments
On souhaite maintenant compléter notre type abstrait de données en implémentant d'autres fonctionnalités.
1. On souhaite ajouter un nouvel opérateur duree-h qui renvoie la valeur d'une durée en heure entre deux dates
(a) Proposez une structure de données pour cet opérateur
(a)
(b) Proposez une implémentation fonctionnelle de cet opérateur en Python.

2. On souhaite ajouter un nouveau prédicat avant qui teste si une date se trouve avant une autre.
(a) Proposez une structure de données pour ce prédicat
(a)
(b) Proposez une implémentation fonctionnelle de ce prédicat en Python.

3.3 Exercices Complémentaires

Vous trouverez tous les exercices complémentaires à rendre dans les notebooks :
. T2.3 Types Abstraits de Données

2.3 Structures de données Page 3/3

J.Devalette