IFT-10541 Structures de données Abder Alikacem Département d’informatique et de génie logiciel

Semaine 1 Synthèse Analyse et abstraction Modélisation Types de données abstraits Spécifications Modèles d'implantation

Mais quel est le problème? Les méthodologies TDA et OO s'adresse au problème du développement de logiciel L’industrie réclame une "production de masse de composants logiciels" pour résoudre la "crise du logiciel“. Coûts logiciels / résultats Source: US Gov. Accounting Report, (in B. Cox, OO Prog.) 29% 19% 2% 3% 47% Delivered but not used Abandoned or reworked Paid for but not delivered Used after rework Used as delivered

Gestion de la complexité La complexité du domaine du problème Grand nombre de besoins, souvent contradictoires Les utilisateurs et les programmeurs ont des problèmes de compréhension mutuelle Changement de besoins (souvent en raison du développement du logiciel)

Gestion de la complexité Difficulté de contrôle du procédé de développement Les grands problèmes mènent à de grandes équipes de développement, ce qui complique la communication Plus la complexité du domaine du problème est grande, plus la gestion du projet devra être ferme.

Gestion de la complexité Flexibilité possible du logiciel Aucunes restrictions physiques du logiciel pour la modélisation de systèmes qui doivent répondre a certains restrictions Aucune normes de construction standardisées Comportement des systèmes discrets Comportement n’est pas continu Par exemple, une balle qui rebondie

Comment gérer la complexité? Modularité Encapsulation Hiérarchie Décomposition Masquage d’information information hiding Abstraction

Décomposition Réduire le problème en plusieurs plus petits problèmes qui sont plus facile à résoudre. Divide & conquer Séparation & isolation du problème à un plus petit domaine. Créer des composants qui collaborent pour créer un système qui effectuera une fonctionnalité désirer. Coupling & cohesion des composantes (couplage vs cohésion)

Hiérarchie Permet de comprendre la relation entre plusieurs petites composantes. Différents types d’hiérarchie permettent de mieux comprendre les différents partie d’un système complexe.

Abstraction Le plus important que la décomposition et les structures hiérarchiques. Permet de négliger les détails moins important. Permet de se concentrer sur le aspect plus important du problème.

Abstraction/Modularité Interface limité Communication limité Interface explicite Masquage des informations Correspond à des unités syntaxiques du langage Fonctions Interface Données

Abstraction/Modularité Un bon module doit pouvoir Manipuler plusieurs types différents S’adapter au différentes structures de données Offrir des opérations sans connaître l’implémentation factoriser les opérations communes à un groupe de module Fonctions Interface Données

Des types aux interfaces Les types de données abstraits Des types aux interfaces

Le typage Question : lien entre les types et les classes ? Nous avons déjà rencontré les types (primitifs) dans la programmation int i; Bool b; b = (i + 1); b = (i == 1); b = (b +1); Les types renforcent une notion de validité Question : lien entre les types et les classes ? Cercle c = new Cercle(2,6,9.0); c.dessiner(); c=7;

Représentation des données Toute donnée en mémoire consiste en une séquence de bits (et d’octets) Le programmeur associe une signification à toute donnée Entier, tableau de caractères 1 Entier x = 21 Record CharPair = { ‘ % ’, ‘ (‘  } En ASCII

Type Cette signification définit Les valeurs légales pour une variable Les opérations applicables aux valeurs C-à-d, le type P.ex. le type int comprend Les valeurs {min, …, max} Les opérations {+, ==, -, *, != } Et division ? Cela dépend du langage de programmation

Utilité du typage Sécurité Génie logiciel Éviter certaines erreurs de programmation bool b = 3.0; /* erreur de typage */ int i,j; j = 0; i= (i div j) /*erreur de typage ?*/ Génie logiciel Programmer mieux Important pour l’interopérabilité de composants de sources différentes

Un système de types Un langage typé associe un type à chaque variable d’un programme La plupart des langages qu’on connaît: C, Pascal, C++, Eiffel, Java Un système de types Détermine le type de toute variable ou expression dans un programme, Et signale les erreurs de type Un système de types est intégré dans le compilateur du langage ou dans son environnement d’exécution

Les règles de typage Tout langage possède ses règles de typage Définissent la validité des expressions d’un langage 1. int + int int 2. 0 * int  0 3. (int = int)  bool P.ex: a=3+6 est légal si a est du type int par la règle 1 La vérification de typage démontre que le programme respecte les règles La vérification est effectuée par le compilateur ou par le run-time

Vérification de typage Statique Vérification s’effectue lors de compilation p. ex. C++, Eiffel Dynamique Vérification à l’exécution P.ex. SmallTalk Java utilise la vérification statique et la vérification dynamique

Typage statique Proc MinMax(int a, b) if a < b then return (a,b); Associe un type à une variable Pas de vérification à l’exécution Toute la vérification est faite à la compilation Restrictif : spécifier les types à la programmation Un programme qui opère sur des données de types différents est utile pour éviter du code redondant ! Proc MinMax(int a, b) if a < b then return (a,b); else return (b,a); Proc MinMax(Complex a,b) if a < b then return (a,b); else return (b,a);

Typage dynamique Proc MinMax(a,b) Type associé à l’objet, pas à la variable Ce programme est correct si le type de a et de b comprend l’opération < Le typage dynamique s’avère plus coûteux à l’exécution, mais plus souple ! Java prend une approche entre les deux extrêmes Proc MinMax(a,b) if type_of(a) != (Complex or Int) then Error; if a < b then return (a,b); else return (b,a);

Les langages non-typés Tous les langages ne sont pas typés P.ex. Le code machine ne possède pas la notion de type toute donnée n’est que séquence d’octets Avantages des langages non-typés Programmation de « bas niveau » C-à-d, on peut manipuler des données de façon uniforme indépendamment de leurs significations P.ex: pour programmer le swap au sein d’un OS Efficacité du langage

Le cadre orienté-objet Java Type Primitifs: byte, int, short, long float, double boolean, char Types Composés Classes class Cercle, class Carre Tableaux char[] Cercle[], Cercle[][]

Types de données abstrait Type Abstrait Opérations ou Services fourni sur des structures de données Propriétés de ces opérations Surface retourne l ’aire X, Y retournent les coordonnées Un objet de la classe Cercle possède le type (abstrait) Cercle Permet d ’obtenir les qualités attendues d ’un logiciel d’aujourd’hui (extensibilité, réutilisabilité, compatibilité) Cercle Opérations Surface X Y

Encapsulation vs Masquage d’information Regrouper (enclosure) ensemble des attributes 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. Donc avec le temps, ils sont devenus des synonymes.

Encapsulation 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 ami visible par toutes les autres méthodes des classes définies dans le même fichier ou package.

Client - Fournisseur - Contrats Un objet demande un service à un autre objet Client: objet qui demande le service Serveur: objet qui satisfait le service Contrat: liste de requêtes qu’un client peut demander à un serveur Satisfaction du contrat: le client n’établit que des requêtes du contrat le serveur répond de manière appropriée aux requêtes Eiffel: attacher des pre- post-conditions aux méthodes Ex: on ne demande pas une pizza au McDonald

Interface L’interface sert de contrat entre un fournisseur et ses clients Une interface remplit le rôle d’un type En énumérant les opérations du type Une classe réalise (ou implémente) un type abstrait Plusieurs classes peuvent réaliser le même type Cela permet de séparer la spécification d’un composant de sa réalisation (génie logiciel) Pour une interface I Les opérations de I sont celles définies par l’interface Les valeurs de I sont celles de tous les objets dont leurs classes implémentent I

Interface En Java, on peut définir une interface public interface Forme{ public float Surface(); public void bouger(int a, int b); public void dessiner(); public int X(); pubic int Y(); } Une interface en Java est comme une classe mais sans le code des méthodes Une Interface définit un type

Interface Une classe peut réaliser une interface La classe est censée fournir une méthode pour toutes celles de l’interface Les entêtes de Cercle et Carré peuvent être écrites ainsi : « class Cercle implements Forme » ou « class Carre implements Forme » Le client est alors assuré qu’un objet d’une classe qui réalise une interface comprend tous les messages de cette interface

Exemple: classe Carré class Carre implements Forme{ int x, y; float cote; Ecran ec; public Carre(int a, int b, float h, Ecran e) { x=a; y=b; cote=h;ec = e;} public float Surface() { return cote*cote} public void bouger(int a,int b) { x = a; y = b;} public int X() { return x;} public int Y() { return y;} public void dessiner() { ec.afficher(this); } }

Interface Polymorphisme: utile pour le code qui manipule des objets de diverses sortes (p.ex: dans la classe Ecran) void afficher(Forme f) Extensibilité: on peut facilement ajouter des nouvelles classes pendant la vie de l’application implements Forme main(){ Cercle c1 = new Cercle(2,3,4.0,e); Carre c2 = new Carre (3,6,7.0,e); Forme f; /* 2 affectations légales */ f = c1; f=c2; /* Exploitation de l’interface */ f.dessiner(); float f1 = f.surface()

Interface vs Implémentation La programmation objet se concentre sur les messages et non sur les données P.ex: Comment faut-il représenter la date ? 17.3.1999 ou 3/17/1999 ou 99.3/17 ? Dans le modèle d’objets Date est une classe avec l’interface: jour(), mois(), année() Pour un objet de la classe date, le mois est donné par d.mois() La représentation interne de la date n’est pas importante

Interface vs Réutilisabilité Une classe peut être réutilisée dans une autre application Un but de la programmation objet ! Parfois la classe ne convient pas à 100% P.ex: pour représenter une cercle en couleur, il faut modifier Cercle pour représenter la couleur P.ex: la classe Cercle ressemble beaucoup à la classe Carré, mais on ne peut pas utiliser l’une pour l’autre

Interface vs Réutilisabilité Le principe ouvert - fermé Une classe doit être fermée par rapport à d’autres classes Le principe de la modularité et Information hiding Accès simplement via l’interface ; l’état interne reste caché Une classe doit être suffisamment ouverte afin de pouvoir l’étendre facilement P.ex: définir une classe Cercle à partir d’une classe Carré Le mécanisme d'héritage

Qu’est-ce objet orienté? Avant 1990 paradigme structurée Après 1990 Paradigme orienté objet Paradigme: façon de penser, de voir les choses.

Paradigme Structuré Données & fonctions séparer fonctions Approche traditionnelle Organiser autour du traitement fonctions donnée

Paradigme OO Nouvelle modularité basé sur des types abstraits: classe qui inclut données et fonctions. qui permet l’ encapsulation (masquage d’information) modularité abstraction

Les objets collaborent Ce n’est plus un arbre de procédure tel qu’en programmation structuré En OO, c’est un réseau d’objets qui collaborent ensemble. Données Fonctions de manipulations et de traitements Objet

Le cadre orienté-objet Le type abstrait permet une définition précise sans décrire l’implémentation Une classe est une implémentation particulière d ’un type abstrait Les opérations du type sont les méthodes définies dans la classe Les valeurs du type sont tous les objets possibles de la classe Il peut y avoir plusieurs implémentations du même type

Types Abstraits et 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

Objets C Opérations Attributs Description Surface X Y Attributs rayon couleur x y Description Surface = pi*rayon*rayon X = x Y = y Un objet fournit un service à d’autres objets Un objet comprend un ensemble de messages (interface) Une méthode sert chaque message Un état caché (composé de variables) qui persiste Application graphique : Seules les méthodes Surface, X et Y peuvent manipuler les variables de l’état

Exemple : Prog.java /* procedure qui démarre l ’application */ main(){ Ecran e; Carre c1, c2; Cercle c; / * Créer les nouveaux objets */ c1 = new Carre(1,2,2.0,e) c2 = new Carre(4,2,5.0,e) c = new Cercle(2,3,2.0,e); /* Afficher les formes */ c1.dessiner(); c2.dessiner(); c.dessiner(); /* bouger carre 1 avec les paramètres de carre 2 */ c1.bouger(c2.X(),c2.Y()); } /* Les paramètres du messages doivent être connus avant l’envoi du message */

Objets c1 e c c2 1 Exécution: ensemble d ’objets … main() 1 Exécution: ensemble d ’objets … … donc: Création des carrés et cercles (avec transfert d’une référence sur l ’écran) 2 Si un objet A possède une référence sur B … … alors A peut envoyer un message à B

result = obj.meth(arg1, arg2, arg3) Messages Un message, ou appel de méthode, est le moyen de communiquer entre objets Un message possède un format bien précis: En Java, un argument (arg) et le résultat peuvent être: Le nom d’un autre objet C-à-d : une référence sur un objet Mécanisme de base pour la distribution d’informations dans un système à objets Ou une valeur simple (int, float, char, bool) result = obj.meth(arg1, arg2, arg3)

Type abstrait et l’orienté objet Les notions fondamentales du raisonnement objet et le type abstrait: la notion de classe; la notion d’encapsulation; l’agrégation; la notion d’héritage; le polymorphisme ; la notion de réutilisation; Les types abstraits sont tout aussi omniprésents mais moins médiatisés! Il est important de bien distinguer objets et types abstraits et comprendre comment ils sont mélangés dans chaque langage

C’est quoi une classe? op 1 Etat caché interface op 2 op 3 Une classe est un enregistrement qui regroupe les noms des attributs et les méthodes. La définition de la classe et la création de l’objet sont séparées les classes sont un type abstrait! Un objet est une entité à l'exécution qui possède: un ensemble visible d'opérations ou méthodes (l'interface) un état caché qui persiste entre les opérations Etat caché op 1 op 2 op 3 interface Les opérations sont déclenchéees par la réception de messages

Classes Une classe définit un moule d’objet Les données participant à l ’état Les messages servis (l’interface) La méthode exécutée pour chaque message Un constructeur est une méthode spéciale Elle est exécutée par tout objet lors de sa création Elle initialise les variables d’état Elle rend un nom unique pour l’objet au créateur C-à-d : une référence sur l’objet Créateur est soit le main() du programme, soit un autre objet

Exemple: classe Cercle class Cercle{ /* Données locales */ int rayon, x, y; Ecran ec; /* Le constructeur */ public Cercle(int a, int b, int r, Ecran e) { rayon = r; x=a; y=b; ec = e;} /* Les méthodes des messages */ public float Surface() { return 3.14*rayon * rayon;} public void bouger(int a,int b) { x = a; y = b;} public int X() { return x;} public int Y() { return y;} /* Un objet cercle envoie un message à l ’écran */ public void dessiner() { ec.afficher(this) ;} }

/* Les méthodes ont les mêmes noms et paramètres! */ Exemple: classe Carré class Carre{ /* Données locales */ int x, y; float cote; Ecran ec; /* Le constructeur */ public Carre(int a, int b, float h, Ecran e) {x=a; y=b; cote = h; ec = e;} /* Les méthodes ont les mêmes noms et paramètres! */ public float Surface() { return cote*cote} public void bouger(int a,int b) { x = a; y = b;} public int X() { return x;} public int Y() { return y;} public void dessiner() { ec.afficher(this) ;} }

Classes Une classe est fournie par un programmeur Le code de la classe est recherché dans une librairie lors de la compilation Sinon, la classe peut être recherchée pendant l'exécution Quand un objet crée lui-même un nouvel objet d’une classe Cercle, le support d’exécution (le run-time) recherche la classe Cercle dans le système de fichiers ou sur le réseau au moment de l’exécution, lorsqu’un objet invoque: new Cercle(...)

Prog.class à l’exécution main(){ Ecran e; - allouer une référence pour e Carre c1, c2; - allouer 2 références pour des Carrés Cercle c - allouer une référence pour un Cercle c1 = new Carre(1,2,2.0,e) - demander à l’environnement de trouver la classe Carre et de la charger en mémoire c2 = new Carre(4,2,5.0,e) c = new Cercle(2,3,2.0,e); A l’aide des classes, les objets sont créés c1.dessiner(); c2.dessiner(); c.dessiner(); c1.bouger(c2.X(),c2.Y()); - L’envoi des messages entre les objets } La liaison du code est faite tardivement On est donc sûr d’avoir la version la plus récente

L’héritage Il peut être intéressant de définir des abstractions sans répéter les parties communes Parties communes = code dupliqué Si une partie est changée, toutes les parties doivent être changées Source d’erreurs! L’héritage est une manière de définir des abstractions de façon incrémentale Une définition A peut “hériter” d’une autre définition B La définition A prend B comme base, avec éventuellement des modifications et des extensions La définition incrémentale A est appelée une classe Attention: le résultat est une abstraction de données complète

Héritage/Réutilisation Encapsulation: meilleure prévention des erreurs Héritage: facilite la réutilisation Réutilisation: existe dans l’approche TDA réutilisation de code approche "boîte noire" approche "boîte blanche" sécurité / vérification encapsulation Typage. Éviter certaines erreurs de programmation Bool b = 3.0; /* erreur de typage */ int i,j; j = 0; i= (i / j) /*erreur de typage ?*/

Le polymorphisme Dans le langage de tous les jours, une entité est polymorphe si elle peut prendre des formes différentes Dans le contexte de l’informatique, une opération est polymorphe si elle peut prendre des arguments de types différents Cette possibilité est importante pour que les responsabilités soient bien réparties sur les différentes parties d’un programme

Le principe de la répartition des responsabilités Le polymorphisme permet d’isoler des responsabilités dans les parties du programme qui les concernent En particulier, une responsabilité doit de préférence être concentrée dans une seule partie du programme Exemple: un patient malade va chez un médecin Le patient ne devrait pas être médecin lui-même! Le patient dit au médecin: “guérissez-moi” Le médecin fait ce qu’il faut selon sa spécialité Le programme “guérir d’une maladie” est polymorphe: il marche avec toutes sortes de médecins Le médecin est un argument du programme Tous les médecins comprennent le message “guérissez-moi”

Conception - Principes Déterminer les objets Quels sont les buts du système? Quels doit être sont comportement vis-à-vis de l ’extérieur De quels objets a-t-on besoin pour réaliser les buts? Déterminer les responsabilités Contrats entre les objets Quelles sont les actions à accomplir? Quel objet accomplit quelle action? Déterminer les collaborations Lien entre objets: clients, fournisseurs (rôles) et contrats

Conception La programmation nécessite une modélisation du système que l’on code Mais comment choisir les classes pour une application ? Expérience ! Souvent beaucoup d ’essais sont nécessaires Parfois, on est restreint par les classes dont on dispose déjà dans nos librairies Et puisqu’il est souvent préférable de réutiliser une classe que d’en coder une nouvelle ….

Objet en C++ Programme C++ Programme C typedef struct { int jour; int mois; int année; } Date; void initData(Data d,int j,int m,int a){ d.jour=j; d.mois=m; d.année=a; } int main(){ Date d; initData(d,2,2,2004); return 0; Class Date { public : void initData(int j,int m,int a); protected: int _jour; int _mois; int _année; }; Date::initData(int j,int m,int a){ _jour=j; _mois=m; _année=a; } int main(){ Date d; d.initData(2,2,2004); return 0;

Interface d’une classe class Date { public : int var1; Date(); ~Date(); void initialiser(int j,int m,int a); void afficher(); int getJour(); int getMois(); int getAnnee(); setJour( int j); setMois(int m); setAnnee(int a); protected: int _jour; int _mois; int _année; void _test(); private: }; Section public Attributs public Méthodes public Constructeur Destructeur Fonction d’accès Section protected Section private

Implantation d’une class Date::Date(){ _jour=0; _mois_0; _annee=0; } Date::~Date(){} void Data::afficher(){ cout << "la date : " << _jour ; cout << "/" << _mois ; cout << "/" << _annee << endl; int Data::getJour() {return _jours;} int Data::getMois() {return _mois;}; int Data::getAnnee(){return _annee;} Data::setJour(int j) {_jour =j;} Data::setMois(int m) {_mois =m;} Data::setAnnee(int a){_annee=a;} Définition des méthodes de la classe : Constructeur Destructeur Fonction d’accès

Entrée sortie Nouvelle librairie C++ : #include <iostream.h> printf(’’ bonjours a tous \n’’); printf(’’ i= %d \n’’,i); printf(’’ f= %f \n’’,f); printf(’’ c= %c \n’’,c); printf(’’ s= %s \n’’,s); scanf(’’%d’’,&i); scanf(’’%f’’,&f); scanf(’’%c’’,&c); scanf(’’%s’’,&s) cout << ’’ bonjour a tous !!! ’’ << endl; cout << ’’ i= ’’ << i << endl; cout << ’’ f= ’’ << f << endl; cout << ’’ c= ’’ << c << endl; cout << ’’ s= ’’ << s << endl; cout << ’’ f= ’’ << f << endl; cin >> i; cin >> f; cin >> c; cin >> s;

Structure d’un programme Fonction principal : main int main(){ ... return ; } int main(int argc, char *argv[]){ /* Programme avec parametres argc : nombre de parametres ( y compris le nom du programme argv : tableau des parametres */ for( int i=0; i< argc;i++) cout << ‘’ parametre ‘’ << i << ‘’ : ‘’ << argv[i] << endl; return 0; C:/programme/Debug> programme.exe il fait beau

Variables Définition des variables au fur et à mesure Constante Taille de tableaux Passage de paramètres int main(){ int a,b=0; a=12; int c; c=12*a+b; int j=0; for(int i=0; i< c;i++) j+=i; return 0; } const int taille=12; int b; b=taille; taille=b;

Allocation dynamique Programme C Programme C++ int main(){ int i; const int taille=10; // Allocation int *pointeur= (int*)malloc(sizeof(int)); int *tab= (int*)malloc(sizeof(int)*taille); // utilisation for(i=0;i<taille;i++) tab[i]=i; // suppression et libération mémoire free(tab); free(pointeur); return 0; } int main(){ int i; const int taille=10; // Allocation int *pointeur= new int; int *tab=new int[taille]; // utilisation for(i=0;i<taille;i++) tab[i]=i; // suppression et libération mémoire delete [] tab; delete pointeur; return 0; }

Tableau en C++ Tableau statique Tableau dynamique int tab[10]; Date tabDate[10]; Int* tab= new int[10]; Date* tabDate= new Date[10];

Pointeurs et références Désigne un espace mémoire int c; int *p; P = new int ;