31
DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-2005 1 Cours n° 8 Cours n° 8 Conception et Programmation à Conception et Programmation à Objets Objets Réutilisation de composants Réutilisation de composants de la bibliothèque standard du C++ (STL) de la bibliothèque standard du C++ (STL) 1/2 1/2 Equipe pédagogique Equipe pédagogique Marie-José Caraty, Denis Poitrenaud et Mikal Ziane Marie-José Caraty, Denis Poitrenaud et Mikal Ziane

Cours n° 8 Conception et Programmation à Objets

Embed Size (px)

DESCRIPTION

Equipe pédagogique Marie-José Caraty, Denis Poitrenaud et Mikal Ziane. Cours n° 8 Conception et Programmation à Objets Réutilisation de composants de la bibliothèque standard du C++ (STL) 1/2. Sommaire. Introduction Conteneurs 1.1.Séquences élémentaires Conteneurs vector, deque, list - PowerPoint PPT Presentation

Citation preview

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20051

Cours n° 8Cours n° 8

Conception et Programmation à ObjetsConception et Programmation à ObjetsRéutilisation de composants Réutilisation de composants

de la bibliothèque standard du C++ (STL) de la bibliothèque standard du C++ (STL) 1/21/2

Equipe pédagogiqueEquipe pédagogiqueMarie-José Caraty, Denis Poitrenaud et Mikal ZianeMarie-José Caraty, Denis Poitrenaud et Mikal Ziane

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20052

Introduction

1. Conteneurs 1.1. Séquences élémentaires

Conteneurs vector, deque, list1.2. Adaptateurs de séquence

Conteneurs stack, queue, priority_queue1.3. Conteneurs associatifs

Conteneur map, set, multimap, multiset

2. Itérateurs

3. AlgorithmesManipulations - OrdonnancementRecherche - Ensemblistes

Conclusion

Sommaire

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20053

STL fournit les fonctionnalités de l'algorithmique de baseEnsemble de composants techniquesTypes abstraits de données (TAD) correspondant aux structures de données classiques (implémentation abstraite des structures de données et de leurs méthodes associées) et d’algorithmes applicables aux TAD

Objectifs à la conception de STL Structures de données et algorithmes doivent fonctionner pour tout type d'élément

type prédéfini/natif du langagetype utilisateur (défini par le programmeur)

Efficacité vitesse d'exécution Abstraction de l'implémentation

Mécanisme de généricitéFondé sur les patrons (templates) de classes, de méthodes et de fonctions

Normalisée en 1995 (ANSI Draft)

Source et documentation disponible sur www.sgi.com/tech/stl/

INTRODUCTIONINTRODUCTION

Standard Template Library (STL)Standard Template Library (STL)

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20054

Conteneurs (container)

Implémentation des structures de données les plus courantes avec leur allocation/désallocation mémoire automatique

Itérateurs (iterator)

Principes d'accès/balayage des éléments des conteneurs

Algorithmes (algorithm)

Implémentation d'algorithmes génériques associés

INTRODUCTION INTRODUCTION

Composants phares de STLComposants phares de STL

itérateur algorithmeconteneur

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20055

1. CONTENEURS 1. CONTENEURS

IntroductionIntroduction

Implémentation générique de structures de données classiques en programmationOrganisation d’un ensemble fini d'éléments de même type

Conteneurs de séquenceEléments organisés suivant un arrangement linéaire Séquences élémentaires (vector, deque, list) Adaptateurs de séquence (stack, queue, priority_queue)

Conteneurs associatifsEléments décrits par des paires (clé, valeur) de type quelconque

et triés par ordre de clé

Recherche rapide (recherche binaire) d'élément (set, map, multiset, multimap)

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20056

vector

Conteneurs

Adaptateursde séquence

listdeque

stack queue priority_queue

map

multimap

set

multiset

Conteneursde séquence

Conteneursassociatifs

1. CONTENEURS 1. CONTENEURS

ClassificationClassification

Séquencesélémentaires

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20057

Inclusion des headers standards de la librairie STL

#include <vector> // Définition de la classe vector#include <list> // Définition de la classe list#include <deque> // Définition de la classe deque #include <stack> // Définition de la classe stack#include <queue> // Définition des classes queue et priority_queue#include <map> // Définition de la classes map#include <multimap> // Définition de la classe multimap#include <set> // Définition de la classe set#include <multiset> // Définition de la classe multiset#include <algorithm> // Algorithmes génériques. Par exemple, copy(..)#include <iterator> // Définition de la classe iterator

using namespace std; // Visibilité des entités déclarées dans la librairie // standard// Sans cette clause d'utilisation : utiliser// le nom qualifié// Préfixe suivi de l'opérateur de résolution de portée// Exemple : std::vector<int> V;

1. CONTENEURS 1. CONTENEURS

Visibilité des composantsVisibilité des composants

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20058

vector

deque

list

Blocs contigus d'objets (vector) ou non contigus (deque, list)Insertion possible en tout point de la séquencePerformance fonction du type de séquence et du point d'insertion

Accès directInsertion/suppression optimisée en fin

Accès direct Insertion/suppression optimisée en début ou en fin

Accès séquentielInsertion/suppression optimisée en tout point

(Double End QUEue)

1.1. SEQUENCES ELEMENTAIRES 1.1. SEQUENCES ELEMENTAIRES

Principes de fonctionnementPrincipes de fonctionnement

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-20059

1.1 SEQUENCES ELEMENTAIRES 1.1 SEQUENCES ELEMENTAIRES

Méthodes communes des séquences élémentaires (1/2)Méthodes communes des séquences élémentaires (1/2)

bool empty();true si le conteneur est vide

size_type size() const;

Nombre d'éléments du conteneur

size_type max_size() const;

Contenance maximale du conteneur

void resize(size_type, T c =T());

Redimensionnement du conteneur

T& front();

Référence sur le premier élément

T& back();

Référence sur le dernier élément

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200510

void push_back(const T& );

Ajout (recopie) de l'élément en fin

void pop_back();

Suppression de l’élément en fin de séquenceiterator insert(iterator, const T& = T());

Insertion d’un élément à l'emplacement spécifié par l'itérateur

void insert(iterator position, iterator debut, iterator, fin)Insertion à la position spécifiée les éléments de [debut fin[

void swap(sequence <T>&back())Echange des éléments de this avec ceux du conteneur argument

void erase(iterator i);Suppression de l'élément pointé par l'itérateur i

void erase(iterator debut, iterator fin);Supprime des éléments de [debut fin[

1.1. SEQUENCES ELEMENTAIRES 1.1. SEQUENCES ELEMENTAIRES

Méthodes communes des séquences élémentaires (2/2)Méthodes communes des séquences élémentaires (2/2)

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200511

Définition de la classe générique vectortemplate <class T, class Alloc=alloc>class vector {...};

2 paramètres formels génériques T : type des éléments du vecteur Alloc : type de la gestion mémoire (allocation/désallocation)

Remarque : Alloc a une valeur par défaut : alloc

Déclaration d’un vecteur : instanciation du générique

Pour déclarer un objet de type vector, on instancie la classe générique vector en précisant (dans l’ordre et séparés par une virgule) les paramètres effectifs correspondants aux paramètres formels génériques

Exemple : pour déclarer un vecteur de flottants

vector <double> vi; //sans autre paramètre, //alloc (paramètre par défaut) est considéré

Notation SGI vector <T, Alloc=alloc> que nous noterons vector <T>

1.1. SEQUENCES ELEMENTAIRES 1.1. SEQUENCES ELEMENTAIRES

Classe générique et instanciationClasse générique et instanciation

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200512

1.1. SEQUENCES ELEMENTAIRES - Conteneur VECTOR 1.1. SEQUENCES ELEMENTAIRES - Conteneur VECTOR

Instanciation, propriétés et méthodes spécifiquesInstanciation, propriétés et méthodes spécifiques

vector <T> v; Déclaration d’un vecteur v d’éléments de type T

vector <T> v(n); Déclaration d’un vecteur v de n éléments de type T

Extension de la structure classique de tableau (liste)Création et variation de la taille au cours de l’exécution

Fonctions d’insertion et de suppression non optimisées (sauf en fin de vecteur)

Méthodes spécifiquessize-type capacity() const;

Capacité actuelle du conteneur

void reserve(size_type); Ajout de capacité

T& operator [](size_type) ou T& at(size_type);Accès direct

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200513

1.1. SEQUENCES ELEMENTAIRES - Conteneur VECTOR 1.1. SEQUENCES ELEMENTAIRES - Conteneur VECTOR

ExempleExemple

#include <iostream>

#include <vector>

using namespace std;

int main() {

int tabEnt[] = {10, 15, 23, 67, 43, 98, 34, 77};

vector <int> vi;

for (int i = 0; i < sizeof(tabEnt) / sizeof(int); i++)

vi.push_back(tabEnt[i]);

cout << "Taille : " << vi.size() << " – Vecteur : ";

for (int i = 0; i < vi.size(); i++) cout << vi[i] << " ";

}

Résultat d’exécutionTaille : 8 – Vecteur : 10 15 23 67 43 98 34 77

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200514

1.1. SEQUENCES ELEMENTAIRES - Conteneur DEQUE 1.1. SEQUENCES ELEMENTAIRES - Conteneur DEQUE

Instanciation, propriétés et méthodes spécifiquesInstanciation, propriétés et méthodes spécifiques

deque <T> d; Déclaration d’une deque d d’éléments de type T

deque <T> d(n); Déclaration d’une deque d de n d’éléments de type T

Fonctionnalités voisines de celles du conteneur vector+ Insertion et suppression en début de séquence plus rapide- Accès direct plus lent

Méthodes spécifiquesvoid push_front(const T&) const;

Insertion d’un élément en début de séquence

void pop_front(); Suppression en début de séquence

T& operator [](size_type); et T& at(size_type);Accès direct

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200515

1.1. SEQUENCES ELEMENTAIRES - Conteneur DEQUE 1.1. SEQUENCES ELEMENTAIRES - Conteneur DEQUE

ExempleExemple

#include <iostream>

#include <deque>

using namespace std;

int main() {

int tabEnt[] = {10, 15, 23, 67, 43, 98, 34, 77};

deque <int> di;

for (int i = 0; i < sizeof(tabEnt) / sizeof(int); i++)

di.push_front(tabEnt[i]);

cout << "Taille : " << di.size() << " – Deque : ";

for (int i = 0; i < di.size(); i++) cout << di[i] << " ";

}

Résultat d’exécutionTaille : 8 – Deque : 77 34 98 43 67 23 15 10

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200516

1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST 1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST

Instanciation, propriétés et méthodes spécifiques (1/2)Instanciation, propriétés et méthodes spécifiques (1/2)

list <T> l; Déclaration d’une liste l d’éléments de type T

list <T> l(n); Déclaration d’une liste l de n d’éléments de type T

Spécialisation de la structure classique de liste+ Fonctions rapides d’insertion et de suppression- Accès séquentielfonctions rapides (tri, concaténation, …)

Méthodes spécifiquesvoid push_front(const T&) const;

Insertion d’un élément en début de séquence void pop_front();

Suppression de l’élément en début de séquencevoid remove(const& T valeur);

Suppression de tous les éléments égaux à valeurvoid remove_if(Predicate pred);

Suppression de tous les éléments vérifiant pred

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200517

void sort([Compare cmp]);Tri des éléments selon l'opérateur < ou le foncteur cmp

void reverse([Compare cmp]));Inversion de l'ordre des éléments selon l'opérateur < ou le foncteur cmp

void unique([Compare cmp]);Suppression sur une liste triée des éléments en double

void merge(list<T> & x [, Compare cmp]);Fusion de la liste triée avec une autre liste x triée de même type,x est vidé.

void splice(iterator i, list<T>& x); Déplacement de la liste x dans la liste this avant l’élément pointé par l’itérateur i

void splice(iterator i, list<T>& x, iterator j); Déplacement de l’élément de x pointé par l’itérateur j dans la liste this avant l’élément pointé par l’itérateur i

void splice(iterator i, list<T>& x, iterator debut, iterator fin); Déplacement de la séquence d’éléments [debut fin[ de x dans la liste this avant l’élément pointé par l’itérateur i

1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST 1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST

Méthodes spécifiques (2/2)Méthodes spécifiques (2/2)

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200518

Variable qui repère la position d'un élément dans un conteneur L’itérateur permet d’accéder/balayer les éléments d'un conteneurA chaque conteneur son type d’itérateur

Quelque soit la classe conteneur : 2 méthodes membres Début de la collection (position du premier élément)

Itérateur renvoyé par la méthode membre begin()

Fin de la collection (position de l'élément "juste après le dernier")Itérateur renvoyé par la méthode membre end()

Accès à l’élémént repéré par l’itérateur It : *It

Exemple :

vector <int> V;

V.begin() V.end()

12 3 25 7 39 27

1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST 1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST

Rôle des itérateursRôle des itérateurs

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200519

1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST 1.1. SEQUENCES ELEMENTAIRES - Conteneur LIST

ExempleExemple

#include <iostream>

#include <list>

using namespace std;

int main() {

int tabEnt[] = {10, 15, 23, 67, 43, 98, 34, 77, 10};

list <int> li;

for (int i = 0; i < sizeof(tabEnt) / sizeof(int); i++)

li.insert(li.begin(), tabEnt[i]);

li.sort(); li.unique(); cout << "Liste : ";

for (list <int>::iterator i = li.begin(); i != li.end(); i++)

cout << *i << " ";

}

Résultat d’exécutionListe : 10 15 23 34 43 67 77 98

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200520

1.2. ADAPTATEURS DE SEQUENCE 1.2. ADAPTATEURS DE SEQUENCE

IntroductionIntroduction

Conteneurs implémentés à partir de séquences élémentaires

stackStructure de données de pile - Last In First Out (LIFO)Insertions et retraits sur le haut de la pile

queueStructure de données de file - First In First Out (FIFO)Insertions en fin et retraits en début

priority_queueStructure de données de file avec priorité (fonction d'un prédicat)Après insertion d’élément, file maintenue triée par ordre croissant de prioritéInsertions en fin et accès/retraits de l'élément de plus forte priorité

Pas d’autres accès (direct ou séquentiel)Par conséquent, pas d’accès/balayage par itérateur

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200521

1.2. ADAPTATEURS DE SEQUENCE – Adaptateur STACK 1.2. ADAPTATEURS DE SEQUENCE – Adaptateur STACK

Instanciation, propriétés et méthodes spécifiquesInstanciation, propriétés et méthodes spécifiques

stack<T, Sequence=deque<T> > p; Déclaration d’une pile p d’éléments de type T

Sequence : séquence élémentaire (générique)

Implémentation d’une structure abstraite de pile

Méthodes spécifiquesbool empty();

true si la pile est vide, false sinon

size_type size() const; Taille de la pile

T& top() :Lecture du sommet de la pile (sans dépiler l’élément)

void push(const T& );Empiler l'élément

void pop();Dépiler un élément

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200522

1.2. ADAPTATEURS DE SEQUENCE – Adaptateur STACK 1.2. ADAPTATEURS DE SEQUENCE – Adaptateur STACK

ExempleExemple

#include <iostream>

#include <vector>

#include <stack>

using namespace std;

int main() {

float tabFlt[] = {10.2, 15.3, 23.1, 67.2, 43.4, 98.8, 34.6};

stack <float, vector<float> > pf;

for (int i = 0; i < sizeof(tabFlt) / sizeof(float); i++)

pf.push(tabFlt[i]);

while (pf.empty() == false) {

cout << pf.top() << " "; pf.pop();

}

}

Résultat d’exécution34.6 98.8 43.4 67.2 23.1 15.3 10.2

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200523

Pile implémentée par un vecteur

stack <int, vector<int> > S;

S.push(8); S.push(4); // assert(S.size() ==2 ); // assert(S.top() == 4);

S.pop(); // assert(S.top() == 8);S.pop(); // assert(S.empty());

1.2. ADAPTATEURS DE SEQUENCE – Adaptateur STACK 1.2. ADAPTATEURS DE SEQUENCE – Adaptateur STACK

ExempleExemple

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200524

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur QUEUE

Instanciation, propriétés et méthodes spécifiquesInstanciation, propriétés et méthodes spécifiques

queue<T, Sequence=deque<T> > f; Déclaration d’une file f d’éléments de type T

Sequence : séquence élémentaire (générique)

Implémentation d’une structure abstraite de file

Fonctions membresbool empty();

true si la file est vide, false sinon

size_type size() const;Taille de la file

T& front() :Lecture de la tête de la file (sans retirer l’élément)

void push(const T& );Ajout de l'élément en queue (sans retirer l’élément)

void pop();Suppression d’un élément en tête de file

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200525

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur QUEUE

ExempleExemple

#include <iostream>

#include <list>

#include <queue>

using namespace std;

int main() {

char tabChr[] = {'p', 'a', 'r', 'i', 's'};

queue <char, list<char> > fa;

for (int i = 0; i < sizeof(tabChr) / sizeof(char); i++)

fa.push(tabChr[i]);

while (fa.empty() == false) {

cout << fa.front() << " "; fa.pop(); }

}

Résultat d’exécutionp a r i s

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200526

File implémentée par une deque queue <int> Q;

Q.push(8); Q.push(2); // assert(Q.size() == 2); // assert(Q.back() == 2); // assert(Q.front() == 8);

Q.pop(); // assert(Q.front() == 2); Q.pop(); // assert(Q.empty());

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur QUEUE

ExempleExemple

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200527

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE

Instanciation, propriétés et méthodes spécifiquesInstanciation, propriétés et méthodes spécifiques

priority_queue<T, Sequence=deque<T>, Compare=less<T> > fp; Déclaration d’une file à priorité fp

d’éléments de type TSequence : séquence élémentaire (générique)Compare : prédicat binaire générique (foncteur) de comparaison d’éléments

Implémentation d’une structure abstraite de file à priorité

Méthodes spécifiquesbool empty();

true si la file est vide, false sinon

size_type size() const; Taille de la file

T& top() :Lecture de la tête de la file (élément prioritaire)

void push(const T& );Ajout de l'élément en queue

void pop();Suppression d’un élément en tête

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200528

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE

Opérateur de comparaisonOpérateur de comparaison

Compare : définition du critère de priorité à partir d’un prédicat binaire de comparaisonbool Compare<T> (const T& arg1, const T& arg2); paramètre générique : T, le type des élémentsretourne vrai si arg1 et arg2 sont ordonnés, faux sinon

6 foncteurs prédéfinis (pour les types natifs) en C++ redéfinissant les opérateurs relationnels :

equal_to <T> retourne (arg1 == arg2)not_equal_to <T> retourne (arg1 != arg2)greater <T> retourne (arg1 > arg2)less <T> retourne (arg1 < arg2)greater_equal <T> retourne (arg1 >= arg2)less_equal <T> retourne (arg1 <= arg2)

Pour un type utilisateur T :Nécessité de redéfinir l’opérateur relationnel correspondant au foncteur choisi

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200529

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE

ExempleExemple

#include <iostream>

#include <deque>

#include <queue>

using namespace std;

int main() {

char tabChr[] = {'p', 'a', 'r', 'i', 's'};

priority_queue<char, deque<char>, less<char> > fp;

for (int i = 0; i < sizeof(tabChr) / sizeof(char); i++)

fp.push(tabChr[i]);

while (fp.empty() == false) {

cout << fp.top() << " "; fp.pop();

}

}Résultat d’exécutions r p i a

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200530

Foncteur less<int> - élément prioritaire, de plus forte priorité

priority_queue <int> P; //ordre décroissant de priorité

P.push(1); P.push(8); P.push(4); // assert(P.size()==3); // assert(P.top() == 8);

P.pop(); // assert(P.top() == 4); P.pop(); // assert(P.top() == 1); P.pop(); // assert(P.empty());

Foncteur greater<int> - élément prioritaire, de plus faible priorité

priority_queue <int, greater<int> > P; //ordre croissant //de priorité

P.push(1); P.push(8); P.push(4); // assert(P.size()==3); // assert(P.top() == 1);

P.pop(); // assert(P.top() == 4); P.pop(); // assert(P.top() == 8); P.pop(); // assert(P.empty());

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE

Exemple – T est un type prédéfiniExemple – T est un type prédéfini

Priorité décroissante

Val

eurs

Priorité décroissante

Val

eurs

DUT2 – Conception et Programmation à Objets – Marie-José Caraty – 2004-200531

Exemple : Gestion de produits par priorité de marge bénéficiaire Le produit prioritaire dans la file est celui de plus forte marge

class Produit {float pV_; // prix de ventefloat pR_; // prix de revient// Définitions du constructeur, des accesseurs,…

};

priority_queue <Produit> P;// Gestion des produits par une // une file à priorité implémentée

// par une deque et less

L’opérateur   "<" doit être redéfini pour le type Produit

bool operator<(const Produit& P1, const Produit& P2) {return (P1.getPV()-P1.getPR())<(P2.getPV()-P2.getPR())

}

1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE 1.2. ADAPTATEUR DES SEQUENCES – Adaptateur PRIORITY_QUEUE

Exemple – T est un type utilisateurExemple – T est un type utilisateur