Structures de données IFT-2000 Abder Alikacem Introduction au cours Semaine 1 Département...
-
Upload
simonette-billet -
Category
Documents
-
view
105 -
download
0
Transcript of Structures de données IFT-2000 Abder Alikacem Introduction au cours Semaine 1 Département...
Structures de donnéesIFT-2000
Abder AlikacemAbder Alikacem
Introduction au cours Semaine 1
Département d’informatique et de génie logiciel
Édition Septembre 2009
! +
Plan
• Introduction• Analyse et abstraction• Modélisation
• Types de données abstraits• Spécifications• Implantation
• Plan et modalités du cours
Viny, la mascotte du cours!!Viny, la mascotte du cours!!
Conventions de représentation
Conventions de représentation de l’information(Interface):• integer idem pour tout programme sur un même ordinateur,
utilisant le même langage: int x;
Conventions d’utilisation (Opérateurs):• integer pas de décimales: x = 5/2;
D’une manière générale, pour définir un type de données, on a besoin dedécrire éventuellement:
• son nom (syntaxe);• sa sémantique;• son domaine de valeurs;• ses contraintes;• etc..
+ son comportement: { opérateurs }
Interface publique
Conventions de représentation
0 0 00
0 0 ±00
± •bit de signe•complément à 1: C1
•complément à 2: C2
Structuration de base = types simples (ex. le type int)
• convention de représentation interne (Modèle interne):
• int x, y;
• choix de représentation interne {implantation de l’interface}
Modèles internes
Conventions transparentes
Transparence des types de base:
00011101010101000101010101010010101010000111111100000101….
0 0 0 1 1
int x;
y = x++;
Types de base
Types de base:• en C/C++:
• int, float, char, double, long, short• tableaux, string, etc.
• en Pascal:• set
• en SmallTalk:• dictionnaires: {<clé,élément>}
Types structurés
types de base modélisation de base• traitement numérique (appl. scientifiques)• traitement de texte (caractères)
types structurés modélisation d’objets• enregistrements (étudiants, cours, BD, …) modélisation orientée objet (OO)
types structurés = agrégation d’éléments de base
Besoin de types plus complexes!
• Caractéristiques d’un système sont souvent difficiles à être représentées directement dans un ordinateur.
• Existences de distances conceptuelles.
• Comment réduire ces distances?• Analyse (descendante) du domaine• Abstraction (à partir des objets informatique de base jusqu’à une
possible représentation du réel)
C’est la modélisation!
Modélisation des données
L’élaboration d’un algorithme est grandement facilité par l’utilisation de types ou structures de données abstraites de plus haut niveau, et de fonctions de manipulations associées.
Une structure de données doit modéliser au mieux les informations à traiter pour en faciliter le traitement par l’algorithme considéré.
Choisir les bons modèles de données est aussi important que le choix de bons algorithmes.
Algorithme et structure de données abstraite sont intimement liés :
Programme = algorithme + données
Programmes et informations
information intermédiaire
outputinput
Programme = Algorithme + données
Construction d’un modèle
Modélisation:
• Réalité Modèle
Principe de la modélisation
Hiérarchie• Relation entre plusieurs petites composantes.• Décomposition. Réduire le système en plusieurs plus petits
systèmes plus faciles à modéliser. Divide & conquer.• Assurer la collaboration pour créer un système qui effectuera les
fonctionnalités désirées.
Masquage d’information. Information hiding.• Encapsulation
• Regrouper (enclosure) ensemble des attributs et méthodes qui logiquement ont une affinité (coupling & cohesion).
• Masquage d’information• Cacher les secrets d’une implémentation.
Abstraction• Permet de négliger les détails moins importants.• Permet de se concentrer sur les aspects les plus importants du
système à modéliser.
Modélisation:
• Réalité Modèle
Construction d’un modèle
Modélisation:
• Réalité Modèle
Construction d’un modèle
x
Modélisation:
• Réalité Modèle
Construction d’un modèle
x
Modélisation:
• Réalité Modèle
float x;
Construction d’un modèle
struct Pt { float x; float y; float z; } ;
float x;
x
Modélisation:
• Réalité Modèle
Construction d’un modèle
struct Pt { float x; float y; float z; } ;
struct Plan { pt p[4]; } ;
x
Modélisation:
• Réalité Modèle
float x;
Construction d’un modèle
struct Boite { Plan pl[6]; };
struct Pt { float x; float y; float z; } Pt;
x
Modélisation:
• Réalité Modèle
float x; struct Plan { Pt p[4]; };
Construction d’un modèle
struct Pt { float x; float y; float z; };
Boite b1;
x
Modélisation:
• Réalité Modèle
float x; struct Plan { Pt p[4]; };
struct Boite { Plan pl[6]; };
Construction d’un modèle
Modélisation = transfert
Boite b1;…b1.rotation(b1,45);…
Modélisation:
• Réalité Modèle
Création d’un modèle
struct boite { Plan pl[6]; };
struct Pt { float x; float y; float z; };
struct Plan { Pt p[4]; };
float x;Boite b1;…b1.rotation(b1,45);…
Modélisation:• modèle près de la réalité• modèle distant des détails d’implantation
typedef struct { plan pl[6]; } boite;
typedef struct { float x; float y; float z; } pt;
typedef struct { pt p[4]; } plan;
float x;Boite b1;…b1.rotation(b1,45);…
boîte noire
Modélisation:• modèle près de la réalité• modèle distant des détails d’implantation
Les types de données abstraites (TDA)
Programme indépendant de l’implantation du type Boite:
Boite b1, b2, b3;b1.creer(…);b2 = b1;b3 = b2;b1.rotation(45);b2.poseSur(b3);
Boite est alors un type abstrait!
Les types de données abstraites (TDA)
Encapsulation vs Masquage d’information
L’encapsulation et le masquage d’information sont la base de la modélisation de données et de la création des types abstraits.
• Encapsulation• Regrouper (enclosure) ensemble des attributs et méthodes qui logiquement ont une affinité (coupling & cohesion).
• Masquage d’information• Cacher les secrets d’une implémentation.
Un n’implique pas nécessairement l’autre, mais dans l’usage courant, les deux concepts sont souvent interchangés. Avec le temps, ils sont devenus des synonymes.
• L’encapsulation des données est différente suivant les langages et dépend des règles de visibilité adoptées par défaut par ces langages.
• On distingue généralement 3 règles de visibilité (on donnera, à titre d’exemple, le mot-clé Java correspondant) pour les différents composants d’une classe (variables d’instance et méthodes):
• publique (public) : visible de partout• protégée (protected) : visible à l’intérieur de la classe et des sous-classes
• privée (private) : visible que pour les méthodes de la classe
• Dans certains langages, il y a aussi une notion de composant friend visible par toutes les autres méthodes des classes définies dans le même fichier ou package.
Encapsulation vs Masquage d’information
Un type de données abstrait modélise l’« ensemble des services » désirés
plutôt que l’organisation intime des données (détails d’implémentation). Il est
créée à partir d’un ensemble de données organisé et reliées logiquement. Il est caractérisée par :
• son contenu• les interactions possibles (manipulation, accès, ...)
• est défini uniquement• par ses conventions d’utilisation• par le comportement des objets de ce type (i.e., par les
méthodes applicables sur les objets de ce type)• ne décrit pas le modèle d’implantation choisi
• sert à isoler les programmes des données (structuration interne)• crée une indépendance des applications face aux modèles
d’implantation (continuité de la programmation structurée)• permet l’encapsulation de la définition d’un type
Les types de données abstraites (TDA)
Les types de données abstraites (TDA)
• La notion de type de données abstrait (T.D.A.), née d’une préoccupation du
génie logiciel, est indépendante de tout langage de programmation. Elle
généralise les types prédéfinis: on veut généraliser cette idée d’objets
manipulables par des opérateurs propres, sans forcément en connaître la
structure interne et encore moins l’implémentation.
• Permet d ’obtenir les qualités attendues d ’un logiciel d’aujourd’hui:
• extensibilité
• réutilisabilité
• compatibilité
Les types de données abstraites (TDA)
Préoccupation de génie logiciel
•se placer à un niveau d'abstraction élevé, identifier précisément les caractéristiques de l’entité (par rapport à ses applications), et en décrire
les propriétés
•é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
•qui permettent à l'utilisateur de se concentrer sur les problèmes de conception en ignorant les détails de réalisation
• 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
Indépendance programmes/données
Indépendance programmes/données:• modularité de développement• facilité d’assemblage de modules• validation modulaire et continue• Réutilisation• Évolution• coût d’entretien
Les types de données abstraites (TDA)
Incarnation d’un TDA
Une incarnation (une réalisation, une mise en œuvre, une « implémentation ») d'un TDA est la déclaration des structures de données particulières et la définition des opérations primitives retenues pour représenter le TDA.
•L’interface (fichier .h)•Et la définition (i.e le code) des opérations primitives dans un langage particulier
L’implémentation (fichier .cpp)
les programmeurs ont deux casquettes:• le concepteur du TDA qui met en œuvre les primitives et doit connaître la représentation interne adoptée. On parle de programmation de bas niveau.• l'utilisateur du TDA qui ne connaît que les services (les opérations) et n'accèdent jamais à la représentation interne. On parle de programmation de haut niveau.
• Interface de communication • Interface explicite (publique)• Masquage des informations• Offrir des opérateurs (du service) sans connaître les détails de
l’implémentation• Factoriser le code de l’implémentation des opérateurs: fonctions privées.
Interface
Données
Fonctionsmain()
L’interface
Avec les types de données de base:
donnéesprogramme
interface
int x, y;
y = x + 1;
int x, y;=, +, -, ++, --, *, /, ...
L’interfacemain()
Avec des types structurés:
donnéesprogramme
interface
boite b1;
rotation(b1,45);
Boite b1;rotation, poseSur, ...
L’interfacemain()
L’interfacemain()
Remarque. On identifie généralement 4 types de « services » :
1. les modificateurs, qui modifient le T.D.A.2. les sélecteurs, qui permettent « d’interroger » le T.D.A.3. les itérateurs, qui permettent de parcourir la structure4. les constructeurs (que l’on verra plus tard)
Exemple :tableau (structure de données élémentaire)modifieur : affectation d’un élément (t[i]=a)sélecteur : lecture d’un élément (t[i])sélecteur : le tableau est-il vide ? (t.size() == 0)itérateur : index d’un élément ([i] ci-dessus)
//Fichier ModeleImplantationListe.h#ifndef _LISTEC__H#define _LISTEC__H#define MAX_LISTE 100typedef enum {FAUX, VRAI} Bool;
typedef struct{
int tab[MAX_LISTE];int cpt;
} Liste; #endif
//Fichier Liste.h#include "ModeleImplantationListe.h"#include "CodesErreur.h"
Liste initListe(int * err);/* */int tailleListe(Liste l, int *err);/* */Bool estVideListe(Liste l, int *err);/* */Liste ajouterListe(Liste l, int x, int pos, int *err);/* */// etc..
// Fichier Liste.h#include <iostream>
#ifndef _LISTEC__H #define _LISTEC__H
class Liste {public: Liste(); //constructeur ~Liste(); //destructeur void ajouter (int x, int pos)
throw(range_error, length_error); int taille() const ; bool estVide() const; //etc…private: static const int MAX_LISTE = 100; int tab[MAX_LISTE]; int cpt;
};#endif
Interface en C++
Interface en C
Exemple d’une interface d’un type abstrait
C’est la partie publique
Exemple d’une implémentation en C
/********************************************************************Fichier Liste.c Version 1.0 Janvier 2007
(c) IFT-10541 Structures de données ********************************************************************/#include "Liste.h"Liste ajouterListe (Liste l, TypeEl x, int pos, int *err){/* objectif: ajouter l'élément x à la liste l en position pos
méthode: décaler vers la droite tous les éléments à partir de la fin de la liste,jusqu'à ce que pos soit atteint
besoins: La liste l, l'élément x, l'indice d'insertion pos et MAX_LISTE,la taille maximale de la liste
connu: MAX_LISTEentrée: l, x, possortie: La liste l mise à jour (si *err = OK), la liste l inchangée sinon.résultat: *err=OK si les pré sont respectées, PAM si pas assez de place, PERR si
la position est erronéehypothèses: pos est compris entre 1 et la taille de la liste + 1 (|L| + 1)
inclusivement, il y a assez de place pour ajouter x.*/
…
Exemple d’une implémentation en C (suite)
Liste ajouterListe (Liste l, TypeEl x, int pos, int *err){ …
if (l.cpt >= MAX_LISTE){
/* La liste est pleine. */*err = PAM;return l;
}/*A: La liste n'est pas pleine */
if ((pos < 1) || (pos > (l.cpt + 1))){
/* Les paramètre fournis sont invalides. */*err = PERR;return l;
}
/*A: pos >= 1 et pos <= taille de la liste + 1 */*err = OK;
//etc...return l;
}
Exemple d’une implémentation en C++
/**Commentaire style Doxygen
* \file Liste.cpp
* \brief Le code des opérateurs de la liste.
* \author Abder
* \version 0.1
* \date septembre 2009
*
* Implémentation de la classe générique Liste.
*
*/#include "Liste.h"
Exemple d’une implémentation en C++
void Liste::ajouter (int x, int pos) throw(out_of_range, length_error){
if (cpt==MAX_LISTE) throw length_error("Ajouter:La liste est pleine");
if (pos < 1 || pos > this->taille() +1) throw out_of_range("Ajouter:Position d'ajout erronée"); //etc…}
#include "Liste.h"
int main(){ Liste l;
try //on essaie un ajout{l.ajouter(1,1); l.ajouter(2,2); l.ajouter(4,8); // erreur..//…
} catch(exception& e) { cerr<<"ERREUR: " <<e.what(); …; } .... return 0;}
/** Commentaire style Doxygen * \fn void Liste:: ajouter (int x, int pos) * * \param[in] x Élément à ajouter * \param[in] pos Position où insérer l'élément * */
Un main de test:Fichier Main.cpp
Interface =
ensemble d’opérations ou servies fournies sur un type abstrait
= (conventions et contraintes + comportement)
={ prototypes des opérateurs} + spécifications formelles
donnéesprogramme
int x, y;
y = x + 1;
Spécifications d’une interfacemain()
donnéesprogramme
interfacespécification d’un type abstrait
choix d’un modèled’implantation
indépendants!!!
L’idée : si un programme marche avec une abstraction de données, il pourrait marcher avec une autre, si l’autre a la même interface et surtout la même spécification.
Spécifications d’une interface
Spécifications « langage C »
Exemple: ajout dans une liste ordonnée L L +i x
• prototype de la fonction implantant l’opérateur:• Liste ajouterListe(Liste l, TypeEl x, int i, int *err);
• préconditions conditions devant être vraies au départ pour assurer le bon fonctionnement de l ’opérateur
• l ne doit pas être pleine et i [1,|L|+1]
• postconditions conditions étant vraies (observables) après l’application (correcte) de l’opérateur
• l contient x et *err = OK si les préconditions sont respectées• l est inchangée sinon et
*err contient:PAM si L est pleine,PERR si i [1,|L|+1]
• valeur retournée en output de l’application de l ’opérateur:• l mise à jour ou l inchangée en cas d'erreurs
Spécifications « C++ »
Exemple: ajout dans une liste ordonnée L L +i x
• prototype de la méthode implantant l’opérateur:• void ajouter(TypeEl x, int i) throw(range_error, length_error);
• préconditions conditions devant être vraies au départ pour assurer le bon fonctionnement de l ’opérateur
• La liste ne doit pas être pleine et i [1,|L|+1]
• postconditions conditions étant vraies (observables) après l’application (correcte) de l’opérateur
• La liste contient x si les préconditions sont respectées• La liste est inchangée sinon et :
• Exceptions les exceptions lancées par la méthode lors d’un problème
• si L est pleine,• si i [1,|L|+1]
• valeur retournée en output de l’application de l ’opérateur:• aucune
Spécifications version dOxygen
Exemple: ajout dans une liste ordonnée L L +i x
• prototype de la méthode implantant l’opérateur:• void ajouter(TypeEl x, int i) throw(range_error, length_error);
/** * \brief Ajouter un nouvel élément dans la liste * * \pre il y a assez de mémoire pour ajouter l'élément x * \pre la position d'ajout, pos, est comprise entre 1 et |L|+1 * * \post la liste comprend un élément de plus * \post la liste est inchangée sinon * * \exception range_error si la position est erronée * \exception length_error si pas assez de mémoire * */
Spécifications version dOxygen (dans une classe)// Le type Liste
class Liste{
public://L'interface...
/**
* \brief Ajouter un nouvel élément dans la liste
*
* \pre il y a assez de mémoire pour ajouter l'élément x
* \pre la position d'ajout, pos, est comprise entre 1 et |L|+1
*
* \post la liste comprend un élément de plus
* \post la liste est inchangée sinon
*
* \exception range_error si la position est erronée
* \exception length_error si pas assez de mémoire
*/
void ajouter(int x, int pos) throw(range_error, length_error);
...
private:
...//Modèle d'implantation
};
Fichier Liste.h
Quand on développe une structure, on doit donc le considérer comme un « type abstrait », c’est-à-dire dont la spécification ne dépend pas de l’implémentation. On parle également de théorie de contrat.
Pour établir cette spécification (qui risque moins de changer que l’implémentation), il faut avoir recours à une documentation complète de chacune des fonctions qui permettent de manipuler les objets du type en question.
La meilleure façon de procéder est d’employer une convention sur la façon de documenter les fonctions.
La convention de documentation la plus utilisée à l’heure actuelle est sans doute celle employée par l’utilitaire Doxygen http://doxygen.org
Doxygen permet de générer automatiquement, à partir du code, une documentation dans un format pratique (le plus souvent html).
Spécifications d’un type abstrait
Modèles d’implantation
Choix d’un modèle d’implantation:
Besoins de l’application: temps de réponse volume de données volatilité des données
Ressources disponibles: temps CPU espace-mémoire systèmes d’exploitation et architecture du système complexité: temps de développement, d’implantation
et de mise à jour
//Fichier ModeleImplantationListe.h#ifndef _LISTEC__H#define _LISTEC__H#define MAX_LISTE 100typedef enum {FAUX, VRAI} Bool;
typedef struct{
int tab[MAX_LISTE];int cpt;
} Liste; #endif
// Fichier Liste.h#include <iostream> using namespace std;
#ifndef _LISTEC__H#define _LISTEC__H
class Liste { public: … //l’interface publique private: static const int MAX_LISTE = 100; int tab[MAX_LISTE]; int cpt; };#endif
En C++En C
Exemple de modèle d’implantation
C’est la partie privée
Avantages des TDA
Écriture de programmes en couches : •la couche supérieure traite le problème dans les termes du domaine
de problèmes•Empiler (x, P)
•la couche inférieure entre dans les détails du langage de programmation
•tab[sp++] = x
Séparation claire •des offres de service •du codage
Et..•facilité de compréhension et d'utilisation des modules de codes•prise en compte de types complexes•briques d'une structuration modulaire rigoureuse•introduction à la programmation objet
Théorie du contrat
Non-respect de la théorie du contrat• On modifie sauvagement les
données dans structures à tous les endroits où on a besoin des structures. On considère que tous les membres de la structure sont accessibles.
• Ça semble plus facile à faire pour un débutant.
• Un changement de conception d’une structure devient impossible dès que le logiciel prend de l’envergure.
Respect de la théorie du contrat
• L’idée est de préparer le logiciel à un changement radical du contenu de la structure.
• On passe obligatoirement par des fonctions pour accéder aux membres structures.
• On ne fait jamais de supposition sur l’existence de tel membre.
• Plus difficile à réaliser pour un débutant.
• Ça facilite les changements de conception de structures.
Avantages des TDA
Avantages des TDA
struct Boite{int taille;int direction;} ; /*définition d’un modèle interne pour un type Boite*//*Les opérateurs du type Boite*/int getTailleBoite(Boite b); /* Retourne la taille de b*/Boite setTailleBoite(Boite b, int nouvelleTaille); /*Assigne une nouvelle taille à b*/Boite augmenterTailleBoite(Boite b, int i); /*Augmente la taille de b d’une valeur égale à i */
Ce programme brise l’encapsulation, à la ligne 4: il y a non respect de la théorie du contrat.int main(){ Boite b; // ligne 1int t; // ligne 2... // ligne 3t = b.taille; // ligne 4t = t+5; // ligne 5b=setTailleBoite(b,t); // ligne 6...}
Exemple
Inconvénients des TDA
L'utilisateur d'un TDA connaît les services mais ne connaît pas leur coût.
Le concepteur du TDA connaît le coût des services mais ne connaît pas leurs conditions d'utilisation.
Le choix des primitives est quelque fois difficile à faire.
Les types abstraits
On doit également toujours se poser les deux questions suivantes dans la conception d’un type abstrait :
n ’y a-t-il pas d’opérations contradictoires ? consistance
a-t-on donné un nombre suffisant d’opérations pour décrire toutesles propriétés du type abstrait que l’on voulait spécifier au départ ?
complétude
Types Abstraits et l’Orienté-Objet
« La conception par objets est la construction de systèmes logiciels prenant la forme de collections structurées d ’implémentations de types de données abstraits »
B. Meyer
Gestionnairede données
Programmeurd’application
interface
donnéesprogramme
spécification formelled’un type abstrait
choix d’un modèled’implantation
Cours de structures de données
Cours de structures de données
Tâches à maîtriser
Gestionnairede données
Programmeurd’application
interface
donnéesprogramme
spécification formelled’un type abstrait
choix d’un modèled’implantation
Analyse:-besoins-contraintes
1
Tâches à maîtriser
Gestionnairede données
Programmeurd’application
interface
donnéesprogramme
spécification formelled’un type abstrait
choix d’un modèled’implantation
Analyse:-besoins-contraintes
Conception:-choisir un modèle d ’implantation-réaliser l’implantation
1 2
Tâches à maîtriser
Gestionnairede données
Programmeurd’application
interface
donnéesprogramme
spécification formelled’un type abstrait
choix d’un modèled’implantation
Analyse:-besoins-contraintes
Conception:-choisir un modèle d ’implantation-réaliser l’implantation
2.1
1 2
Tâches à maîtriser
Gestionnairede données
Programmeurd’application
interface
donnéesprogramme
spécification formelled’un type abstrait
choix d’un modèled’implantation
Analyse:-besoins-contraintes
Conception:-choisir un modèle d ’implantation-réaliser l’implantation
2.1
1 2
Tâches à maîtriser
Gestionnairede données
Programmeurd’application
interface
donnéesprogramme
spécification formelled’un type abstrait
choix d’un modèled’implantation
2.2
Tâches à maîtriser
Conception d’un type abstrait :
Définition Implantation Utilisation
Mais pas nécessairement par les mêmes personnes
Tâches à maîtriser
Conception d’un type abstrait :
DéfinitionDéfinition L’analyse du problème mène à définir un type abstrait. La définition se fait sans penser à l’implantation
(indépendance de l’implantation) Les spécifications formelles.
Implantation Utilisation
Tâches à maîtriser
Conception d’un type abstrait :
Définition ImplantationImplantation
Il y a différente façon d’implanter, le choix dépend de plusieurs facteurs (besoins, ressources, …)
Les commentaires d’implémentation. Utilisation
Tâches à maîtriser
Conception d’un type abstrait :
Définition Implantation UtilisationUtilisation
L’utilisateur n’a pas à connaître le choix d’implantation. L’utilisateur a accès uniquement aux spécifications
formelles du type abstrait.
Objectifs du cours
Programmation des structures de données et des algorithmes qui les manipulent.• Concepts : abstraction, généricité, encapsulation, programmation orienté
objet• Techniques : la manipulation des pointeurs, la gestion de la mémoire
dynamique Structures de données
•Listes, Piles, Files, Arbres, Graphes, Tables de dispersion
•Tris
Choix : Présentation sous forme de Types de Données Abstraits• Analyse d’algorithmes (notation asymptotique)• Écriture de programmes lisibles et efficaces (complexité)
Discussion sur le plan de cours
• Contenu du cours• Évaluations• Apprentissage du langage C++• Compilateurs, OS• Manuel, site Web, liste de diffusion, forum, courriel• Laboratoires, autres exercices• SVN, dOxygen, Eclipse, VS 2008• Les équipes dans les TPs• Conseils..
Le point sur les normes de programmation
Normes de programmation:
• Commentaires d’interface• Commentaires d’implémentation• Découpage logique d’un programme• La gestion des exceptions• Style de programmation
Voir sur le site Web du cours, section Documentations/Normes de programmation:
•NormesProgrammation.pdf•Resume.h (à propos des commentaires Doxygen)