La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Structures de données IFT-2000 Abder Alikacem Introduction au cours Semaine 1 Département d’informatique et de génie logiciel Édition Septembre 2009.

Présentations similaires


Présentation au sujet: "Structures de données IFT-2000 Abder Alikacem Introduction au cours Semaine 1 Département d’informatique et de génie logiciel Édition Septembre 2009."— Transcription de la présentation:

1 Structures de données IFT-2000 Abder Alikacem Introduction au cours Semaine 1 Département d’informatique et de génie logiciel Édition Septembre 2009

2 Plan • Introduction • Analyse et abstraction • Modélisation • Types de données abstraits • Spécifications • Implantation • Plan et modalités du cours

3 Viny, la mascotte du cours!!

4 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 de décrire éventuellement: • son nom (syntaxe); • sa sémantique; • son domaine de valeurs; • ses contraintes; • etc.. + son comportement: { opérateurs } Interface publique

5 Conventions de représentation ±00 ± •bit de signe •complément à 1: C 1 •complément à 2: C 2 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

6 Conventions transparentes Transparence des types de base: … int x; y = x++;

7 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 (décomposition descendante) du domaine • Abstraction (à partir des objets informatique de base jusqu’à une possible représentation du réel) •Encapsulation • Masquage d’information • Cacher les secrets d’une implémentation. C’est la modélisation!

8 Modélisation: • Réalité  Modèle Construction d’un modèle

9 Modélisation: • Réalité  Modèle  Construction d’un modèle

10 Modélisation: • Réalité  Modèle  Construction d’un modèle

11 x Modélisation: • Réalité  Modèle  Construction d’un modèle

12 x Modélisation: • Réalité  Modèle  float x; Construction d’un modèle

13 struct Pt { float x; float y; float z; } ; float x; x Modélisation: • Réalité  Modèle   Construction d’un modèle

14 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

15 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

16 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

17 Modélisation = transfert Boite b1; … b1.rotation(b1,45); … Modélisation: • Réalité  Modèle 

18 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

19 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)

20 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)

21 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)

22 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)

23 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.

24 Avec les types de données de base: donnéesprogramme interface int x, y; y = x + 1; int x, y; =, +, -, ++, --, *, /,... L’interface main()

25 Avec des types structurés: donnéesprogramme interface boite b1; rotation(b1,4 5); Boite b1; rotation, poseSur,... L’interface main()

26 //Fichier ModeleImplantationListe.h #ifndef _LISTEC__H #define _LISTEC__H #define MAX_LISTE 100 typedef 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 #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

27 //Fichier ModeleImplantationListe.h #ifndef _LISTEC__H #define _LISTEC__H #define MAX_LISTE 100 typedef enum {FAUX, VRAI} Bool; typedef struct { int tab[MAX_LISTE]; int cpt; } Liste; #endif // Fichier Liste.h #include 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 Modèle d’implantation C’est la partie privée Exemple

28 Exemple d’une implémentation en C /******************************************************************** Fichier Liste.c Version 1.0 Janvier 2007 (c) IFT 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_LISTE entrée: l, x, pos sortie: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ée hypothè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. */ …

29 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 (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; }

30 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"

31 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 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: " <

32 Interface = ensemble d’opérations ou servies fournies sur un type abstrait = (conventions et contraintes + comportement) = { prototypes des opérateurs} + spécifications formelles données programme int x, y; y = x + 1; Spécifications d’une interface main()

33 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

34 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

35 L'interface... /** * \brief * * \pre * * \post * * \exception */ Résumé des balises de Doxygen Implémentation... /** * \fn * * \param[in] * \param[out] * * \return Section Documentations/Normes de programmation: •Resume.h (à propos des commentaires Doxygen)

36 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

37 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

38 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 1 int t; // ligne 2... // ligne 3 t = b.taille; // ligne 4 t = t+5;// ligne 5 b=setTailleBoite(b,t); // ligne 6... } Exemple

39 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.

40 Analyse: -besoins -contraintes Conception: -choisir un modèle d ’implantation -réaliser l’implantation Tâches à maîtriser Gestionnaire de données Programmeur d’application interface donnéesprogramme spécification formelle d’un type abstrait choix d’un modèle d’implantation 2.2

41 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é)

42 Discussion sur le plan de cours • Contenu du cours • Prerequis • Évaluations • Apprentissage du langage C++ • Compilateurs, OS • Notes de cours et le manuel recommandé • Site Web, liste de diffusion, forum, courriel • Laboratoires, autres exercices • SVN, dOxygen, Eclipse, VS 2008 • Les équipes dans les TPs • Charge de travail • Conseils •Méthode de travail •Utilisation du site Web du cours

43 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)


Télécharger ppt "Structures de données IFT-2000 Abder Alikacem Introduction au cours Semaine 1 Département d’informatique et de génie logiciel Édition Septembre 2009."

Présentations similaires


Annonces Google