Modèles et STL

Transcription

Modèles et STL

IV. Modèles, Standard Template
Library (STL)

La généricité permet de créer des modèles
paramétrés



La bibliothèque standard repose sur




de fonctions
de classes
des modèles de conteneurs divers (tableaux,
listes…)
Des itérateurs offrant une manière uniforme de
travailler sur ces conteneurs
des algorithmes généraux sur ces conteneurs
Les bibliothèques Boost (en passe d'entrer dans
le standard) offrent de nombreux autres services
POO en C++ © Jacques Farré UNS 2013
Généricité et STL 1/52
Paramètres d'un modèle

Liste des paramètres d’un modèle :
<P1, …, Pn>
avec Pi de la forme
–
–
typename nom
class nom, les deux sont équivalents) :
le paramètre effectif peut être n’importe quel type
unType nom :



(ou
le type unType doit être un type entier ou un type pointeur
le paramètre effectif doit être une expression constante
de ce type
On peut donner des valeurs par défaut en fin
de liste : <typename T = int, int S = 10>
Modèles de fonctions

Exemple
suppose que le type qui
instancie T est muni de operator<
template <typename T>
T min (T a, T b) { return a (a,5);
crée la fonction float min (float a, float b)

ou instanciation implicite :
int a, b; … b = min(a,5);
crée la fonction int min (int a, int b)
pas de conversion sur le type des arguments :
min(3, 1.2)
Spécialisation d’un modèle de
fonction

L’instanciation d’un modèle ne convient pas
toujours const char* a = “foo”;
const char* b = min(a, “bar”);
crée la fonction
const char* min (const char* a, const char* b) {
return a const char* min (const char* a,
const char* b)
{ return strcmp (a, b) < 0 ? a : b; }
Les templates sont un langage de
programmation à la compilation
template <int n> int Fib() {
return Fib<n - 1>() + Fib<n - 2>();
};
template <> int Fib<0>() { return 0; };
template <> int Fib<1>() { return 1; };
int main() {
cout << Fib<40>() << endl;
}
Chaque Fib<k> calculé à la compilation
→ temps linéaire à l’exécution
Si optimisation, Fib<40> peut être calculé à la compilation
→ temps constant à l'exécution
Modèle de fonction appliquant une
fonction

Modèles = code plus court, plus lisible, plus souple
template <typename Predicat>
int chercher (string s, Predicat p) {
// chercher selon le critère p
int i = 0;
while (i < s.size() && !p(s[i])) ++i;
return i;
}
On demande à un
Predicat p
d’avoir une opération
compatible
avec la signature
bool p(char)
bool chiffre(char c) { return ‘0’ <= c && c <= ‘9’; }
string s = "abcd0xyz";
...
int c = chercher (s, chiffre);
#include <ctype.h>
OK aussi avec int isdigit (int)
int m = chercher (s, isdigit); (conversions char → int et int → bool)
Objet-fonction

Objet-fonction (functor) : toute instance de
classe ayant (au moins) un opérateur ()
class sous_chaine {
public :
sous_chaine (const string& s) : cha(s), pos(0) {}
un objet sous_chaine nommé p
bool operator() (char c) {
a une opération compatible avec
bool ok = (c == cha[pos]);
la signature bool p(char)
if (ok) ++pos; else pos = 0;
return ok && pos == cha.size();
}
protected:
int pos;
string cha;
};
int k = chercher (s, sous_chaine("xy"));
Modèles de classes

exemple :
template <int Taille, typename TypeElem>
class tableau {
public :
TypeElem& operator[] (int x) {
if (x < 0 || x >= Taille) throw BadIndex();
return tab[x];
}
private:
TypeElem tab[Taille];
};

instanciation toujours explicite :
tableau<10,double> vecteur;
tableau<20, tableau<10,double> > matrice;
ne pas oublier l’espace,
sinon opérateur >>
Modèle de classe amélioré

Comment permettre
mais pas
tableau<10,int> t;
const tableau<10, int> c;
j = t[i]; j = c[i]; t[i] = j;
c[i] = 1;
template <int Taille, typename T>
class tableau {
public :
…
un const T& ne peut pas
T& operator[] (int x) {
être à gauche d’un =
→ erreur à la compilation
return tab[x];
}
const T& operator[] (int x) const {
return tab[x];
}
private:
TypeElem tab[Taille];
};
Modèles de classes et héritage

Modèles et héritage sont complètement
compatibles : soit class A {…};
class M {…};
–
–
–
Modèle héritant
d’un modèle
class N : public M<T> {…};
modèle héritant
d’une classe
class P : public A {…};
classe héritant
class B : public M<int> {…};
d’une instanciation
et toute autre combinaison
de modèle
Modèles de classes et modèles de
fonction

Modèle de fonction sur un modèle de classe :
template <int N, typename T>
void afficher (const tableau<N,T>& t) {
for (int i = 0; i < N; ++i) cout << ‘ ’ << t[i];
}
tableau<10,double> vecteur; … afficher (vecteur);
ction
n
o
f
a
ci e l
n
a
t
s
n
i
void afficher (const tableau<10,double>& t) {
for (int i = 0; i < 10; ++i) cout << ‘ ’ << t[i];
}
ostream& operator<<(ostream&,double)
tableau<20,tableau<10,double> > matrice;
afficher (matrice); // pas de << sur tableau<10,double>
Modèles de classes et modèles
d’opérateur

Modèle d'opérateur et modèle de classe :
ostream& operator<< (ostream& os, const tableau<N,T>& t) {
for (int i = 0; i < N; ++i) os << ‘ ’ << t[i];
return os << endl;
}
tableau<20, tableau<10,double> > matrice;
ins
tan
cout << matrice;
cie
ostream& operator<< (ostream&, const tableau<20, tableau<10,double> >& t) {
for (int i = 0; i < 20; ++i) os << ‘ ’ << t[i]; i
ns
ta
return os << endl;
nc
ie
}
ostream& operator<< (ostream&, const tableau<10,double>& t) {
for (int i = 0; i < 10; ++i) os << ‘ ’ << t[i];
return os << endl;
}
Modèles de classes et modèles de
fonction amie

On veut éviter de passer par opérator[] des
tableaux pour écrire operator<< des tableaux
ostream& operator<< (ostream& os, const tableau<N,T>& t) {
for (int i = 0; i < N; ++i) os << ‘ ’ << t.tab[i];
return os << endl;
attribut privé
}
→ le déclarer comme ami
class tableau {
friend ostream& operator<< <N,T> (ostream&, const tableau<N,T>&);
Pour un N et un T donnés,
…
};
ostream& operator<<(ostream&, const tableau<N,T>&)
est ami de tableau<N,T>
Modèles de classe et amitié

Pour toutes les instanciations A de
class A {
friend void F(int);
friend void G(T x);
// F(int) amie de toutes les A
// G(U x) (non template) amie de A :
friend void H<T>(T x); // H(U x>) (template) amie de A :
template <typename X>
friend void P(X);

// toute instanciation P(Y) est
// amie de A
Analogue pour l’amitié entre classes
Modèles de classes (des pointeurs
plus sûrs)

Les pointeurs C



ne sont pas initialisés à 0 int* p; *p = 1; ???
aucune vérification lors d’une utilisation
Une classe
de pointeurs
plus sûrs


initialise
vérifie
Ptr<int> p;
*p = 1;
⇒ exception
class ptr {
public :
ptr (T* q = 0) : p (q) {}
T& operator* const () {
if (p == 0) throw NullPointer();
return *p;
}
private:
T* p;
};
Modèles de classes (des pointeurs
plus sûrs)
class A { ptr<A> p = new A (…);
…
(*p).x = 1; OK
int x;
p->x = 2; ⇒ définir ->
};
class ptr {
public :
...
T* operator-> () const {
if (p == 0) throw NullPointer();
return p;
}
operator-> doit retourner
private: un type sur lequel -> est défini aussi
T* p;
};
Modèles de classes (des pointeurs plus
sûrs)
Ptr<A> p; Ptr<A> q;
p = q; OK
mais problème si:
class B : public A {
…
};
ptr<A> pa; ptr pb;
…
pa = pb; un ptr n'est
pas un ptr<A>
⇒ définir un
modèle de
operator=
class ptr {
public :
...
template <typename U>
ptr<T> operator= (ptr q) {
p = q.p; return *this;
}
erreur à la compilation
private:
si pas de conversion
T* p;
U* → T*
};
sûrs)
Ptr<A> p; Ptr<A> q;
p = q; OK
mais problème si:
class B : public A {
…
};
ptr<A> pa; ptr pb;
…
pa = pb; un ptr n'est
pas un ptr<A>
⇒ définir un modèle
de operator=
⇒ déclarer les ptr
amis des ptr<T>
class ptr {
public :
template<typename U>
friend class ptr;
...
ptr<T> operator= (ptr q) {
p = q.p; return *this;
}
mais ptr.p
private:
privé pour ptr<T>
T* p;
ptr;
→ erreur à la compilation
};
sûrs)
Ptr pb; Ptr<A> pa = pb;
un ptr n'est
pas un ptr<A>
⇒ définir un modèle
de constructeur
class ptr {
public :
template<typename U>
friend class ptr;
...
class X {…};
class Y {…};
ptr (ptr q) : p(q.p) {} class Z : public X {…};
private:
T* p;
};
erreur si pas de
conversion U* → T*
ptr<Z> pz = new Z(…);
ptr<Y> py = pz; // NON
ptr<X> px = pz; // OK
Spécialisation d’un modèle de classe


On veut dimensionner un tableau à n !
int tab [fact(5)] impossible, car fact(5) n’est
pas une constante
Mais les modèles le permettent :
template<int N>
class fact {
public:
static const int val = fact<N-1>::val * N;
};
template<> class fact<1> { // specialisation pour N=1
public:
static const int val = 1;
};
solution autorisant int tab [fact<5>::val]
Standard Template Library

La STL fournit entre autre


des classes pour les entrées-sorties
des classes pour les structures de données
classiques
structures séquentielles : vector, list, deque …
structures associative : (multi)set, (multi)map …
des itérateurs offrant une interface uniforme
pour manipuler ces structures
des algorithmes variés sur ces structures
…
Un lien utile :





http://www.sgi.com/tech/stl/
Principes de conception de la STL

S'appuyer sur les concepts orientés objets et
la généricité
–
pour des raisons internes d'architecture logicielle :
•
•
•
–
organisation du code
réutilisation (factorisation) de composants
facilités de maintenance
pour des raisons externes d'utilisation
•
•
•
modularité d'utilisation
facilités de composition
extension et enrichissement par le client
Flots d’entrée-sortie

Voir par exemple www.cplusplus.com/ref/
ou sunsite.ualberta.ca/Documentation/Gnu/gcc2.95.2/html_chapter/iostream_toc.html




Flots d’entrée (consommation : istream) et de
sortie (production : ostream) ou les 2
(iostream)
Sur un fichier (fstream) ou dans une chaîne de
caractères (strstream)
Classes concrètes : ofstream, ifstream,
istrstream, ostrstream
Instances prédefinies : cout, cerr, cin, …
Hiérarchie des classes d’entréesortie
streambuf
ios_base
Mode d'ouverture, formattage…
basic_ios
Erreurs, buffer…
istream
istrstream
(indépendante du format des caractères)
ostream
ifstream
ofstream
ostrstream
Flots sur fichier et chaînes : exemple
sur fichier
#include <iostream>
On peut aussi préciser
#include <fstream>
le mode d’ouverture
using namespace std;
…
ofstream myfile ("example.txt");
sur chaîne
if (myfile.is_open()) {
#include <iostream>
myfile << “blabla\n";
#include <stringstream>
myfile.close();
using namespace std;
}
…
le destructeur fermera le fichier
int a, b;
si vous avez oublié
stringstream ins ("34 22“);
ins >> a >> b;
Flots d’entrée-sorties : principaux
opérateurs

En dehors de << et >>, on a aussi (parmi
d’autres) :
ostream&
ostream&
istream&
istream&

ostream::put (char c)
ostream::write (string s, int lg)
istream::get (char& c)
istream::getline (char*, int lg,
char delim = endl)
Etat d’un flot :
while (cin >> c) …

if (!cin.eof()) …
Opérateurs de manipulation (<iomanip>)
cout << setfill(‘0’) << setw(4) << setbase(16)
<< 127;
affichera 00FF
Chaînes de caractères


Classe string
C’est une instanciation d’une classe générique
(basic_string) avec le type char des caractères
(http://www.sgi.com/tech/stl/basic_string.html)






Sémantique de valeur
Accesseurs : size() (ou length()), opérateur []
Itérateurs en avant et en arrière
Affichage (<<), lecture (>>)
Concaténation (+, +=) et comparaisons (==, !=, <, …)
Diverses méthodes de recherche, insertion,
suppression, remplacement de caractère
Exceptions
class exception {
public:
exception() throw();
exception(const exception&) throw();
exception& operator=(const exception&) throw();
virtual ~exception() throw();
virtual const char* what() const throw();
};
exception
bad_exception
logic_error runtime_error
bad_alloc bad_cast bad_typeid
Héritage abstrait (héritage de
propriétés)

Héritage abstrait : si un concept C a un ensemble de
propriétés P, tout type T ayant les propriétés P est
un raffinement de C


ne se traduit pas nécessairement (et pratiquement jamais
dans la STL) par un lien d’héritage
exemple : un prédicat unaire est un concept qui prend un
seul paramètre et retourne un booléen, donc :
bool EstPair (int x) { return x % 2 == 0; }
struct EstImpair {
bool operator() (int x) { return x % 2 == 1; }
} x;
EstPair et x sont des prédicats unaires car on peut
écrire if(EstPair(i))… et if(x(i))…
Concepts des structures de
données de la STL

Ils sont définis par l’héritage abstrait suivant
Assignable (sémantique de valeur)
Container (possède des itérateurs)
Forward Container (possède des itérateurs vers l’avant)
Reversible Container (possède aussi des itérateurs vers l’arrière)
Random Access Container (possède aussi des itérateurs à accès direc
Concepts des structures de
données de la STL

Structures séquentielles
Forward Container
Sequence (les éléments sont rangés selon un ordre strict)
Front Insertion Sequence
(les éléments sont ajoutés en tête)
Back Insertion Sequence
(les éléments sont ajoutés en queue)
Structures de données concrètes de
la STL

Structures séquentielles concrètes (partiel)
Random Access Container Reversible Container
operator[] (int)
Back Insertion Sequence
Front Insertion Sequence
back
push_back
pop_back
front
push_front
pop_front
vector
list
la STL

Exemple d’utilisation des vecteurs et des
listes
vector<int> v;
for (int i = 0; i < n; ++i) v.push_back (i);
list<int> l;
// recopie inversée du vecteur dans la liste
// en vidant le vecteur
while (v.size() > 0) {
l.push_front (v.back()); v.pop_back();
}
Structures de données abstraites de
la STL

Structures
associatives
Container
Associative Container (les éléments sont rangés par clés)
Simple Associative Container
(les éléments sont leur clé)
Sorted Associative Container
(ordre sur les clés)
Unique Associative Container
(chaque clé est unique)
Pair Associative Container
(l’élément E est accédé par une clé C)
Hashed Associative Container
(hash-code sur les clés)
Multiple Associative Container
(une clé peut y être plusieurs fois)
la STL

Structures associatives concrètes (partiel)
Simple AC
Pair AC
Sorted AC Unique AC
set
map
la STL

Exemple d’utilisation des ensembles et des
maps
int main (int argc, const char* argv[]) {
set<string> mots;
for (int i = 1; i < argc; ++i) mots.insert(argv[i]);
map<string, int> occur; string m;
// compter le nombre d’occurrences dans le texte
// d’entrée des mots présents dans « mots »
while (cin >> m) // simplifié: pb avec les ponctuations
if (mots.find (m) != mots.end())
occur[m]++;
si l'exécutable
« compter »
./compter
le la s'appelle
les < untexte.txt
Itérateurs de la STL


Les itérateurs de la STL sont une
généralisation de la notion de pointeur sur
une collection d’objets
Ils permettent de parcourir les éléments
d'une structure indépendamment de
l'implémentation



ils fournissent une interface commune pour tous
les conteneurs
il peuvent être constant ou non constant (c’est à
dire capable ou non de modifier la structure)
Hiérarchie abstraite :
Random access → bidirectional → forward → input
→ output
Utilisation des itérateurs

Itérateurs en avant : iterator,
const_iterator
set<string> mots;
// afficher les mots de l’ensemble
for (set<string>::const_iterator
i = mots.begin(); i != mots.end(); ++i)
cout << *i << endl;

Itérateurs en arrière : reverse_iterator,
const_reverse_iterator
list<int> l; int k = 0;
// la liste (1,2,3) devient (4,4,4)
for (list<int>::reverse_iterator
i = l.rbegin(); i != l.rend(); ++i)
*i += ++k;
Opérations sur les itérateurs de la
STL

Opérations sur tout itérateur :
* unaire
construction par copie, =, ==, !=
++ préfixe & postfixe

Opérations sur les itérateurs bidirectionnels :
-- préfixe & postfixe

Opérations sur les itérateurs à accès direct :
± entier, -, comparaisons
s.begin()
structure
++
--
s.end()
s vue comme un collection d’objets rangés consécutivement
s.rend()
++
--
s.rbegin()
Utilitaires de la STL :
template <class T1, class T2>
struct pair {
typedef T1 first_type;
–
Couples:
typedef
T2 second_type;
T1 first;
T2 second;
pair()
:first(T1()), second(T2()) {}
pair(const T1& a, const T2& b)
:first(a), second(b) {}
pair
Les pair<clé, elem>
sont les éléments des maps
map<string, int> occur;
for (map<string, int>::iterator
i = occur.begin();
i != occur.end();
++i)
cout << (*i).first << ‘:’
<< (*i).second << endl;
template <class U1, class U2>
pair(const pair<U1, U2>& p)
:first(p.first),
second(p.second) {}
};
Concepts de fonctions de la STL

Objets fonction : opérations arithmétiques,
comparaisons …
template <class T1, class T2, class T>
struct binary_function {
typedef T1 left_type;
typedef T2 right_type;
typedef T result_type;
};
template <class T>
héritage en fait
struct plus : binary_function <T, T, T> {
inutile (sauf pour
T operator() (const T& x, const T& y) {
avoir les typedef)
return x + y;
}
plus<int> addent;
};
int x = addent (1, 3);
Algorithmes de la STL


Très liés aux itérateurs
Applicables sur toute structure de données
–
algorithmes ne modifiant pas la structure de données :
for_each, count, count_if, find , find_if…
vector<int> v; …
find (v.begin(), v.end(), 20);
// retourne un itérateur sur le premier entier égal à 20
struct plus_grand_que {
const int n;
plus_grand_que (int v) : n(v) {}
bool operator() (int v) { return v > n; }
};
…
list<int> l; …
find_if (l.begin(), l.end(), plus_grand_que(10));
Algorithmes de la STL
–
algorithmes modifiant la structure de données :
copy, reverse, transform, replace , replace_if…
vector<int> v; list<int> l; …
copy (v.begin(), v.end(), l.begin());
// copie le vecteur dans la liste
copy (istream_iterator<int>(cin),
l’«itérateur» de fin de fichier
istream_iterator<int>(),
back_inserter(v));
// lit les entiers sur l’entrée standard
// et les range dans le vecteur
–
algorithmes variés de tri, de fusion…
Programmer « sans boucles »

Affichage d’une structure de données
class print {
public :
print (ostream& o) : os (o), prem (true) {}
void operator() (const T& e) {
if (prem) prem = false; else os << ‘ ’;
os << e;
toute classe container
}
template<typename T>
protected :
de la STL définit (public)
ostream& os; bool prem;
typedef T value_type;
};
template <typename SD>
ostream& operator<< (ostream& os, const SD& s) {
for_each (s.begin(), s.end(), print<SD::value_type>(os));
return os;
}
Binders

Binder = objet-fonction fixant un opérande
permet d’utiliser une fonction binaire
comme une opération unaire
template <class Op>
class binder1st
: public unary_function <Op::right_type, Op::result_type> {
protected:
Op oper; Op::left_type value;
montrent l’intérêt
des typedef dans
struct binary_function
public:
binder1st (const Op& x, const Op::left_type& y)
: oper(x), value(y) {}
Op::result_type operator() (const Op::right_type& y) {
return oper (value, y);
}
de même, Binder2nd fixe l'opérande droit
};
et effectue l'opération avec l'opérande gauche
Utilisation des binders

Création d’un binder (défini par la STL)
template <class Oper, class T>
binder2nd<Oper> bind2nd (const Oper& op, const T& v2) {
return binder2nd<Oper> (op, Oper::right_type (v2));

Exemple d’utilisation d’un binder : dans un
vecteur, on veut remplacer toutes les valeurs
négatives qui suivent le premier 0 par 1
vector<int> v;
…
replace_if (find (v.begin(), v.end(), bind2nd(equal<int>, 0),
v.end(),
bind2nd(less<int>, 0),
1);

Autre forme de liaison en C++2011 et λ-expressions
Espaces de noms

Pour éviter des collisions dans les
identificateurs, on peut regrouper un
ensembles de types, variables, … dans un
namespace


analogue à un package Java
noter qu’une classe est aussi un espace de nom
namespace maths {
double sinus (double);
…
};
namespace anatomie {
class sinus { … }
…
};
double x = maths::sinus(maths::pi/3);
using namespace anatomie; sinus s1 (…);
Espaces de noms

On peut étendre un namespace
namespace maths {
const double pi = 3.1416;
…
};




#include “maths1.h”
namespace maths {
double sinus (double);
…
};
Le namespace de la STL est std
Tout identificateur X non déclaré explicitement dans
un namespace est dans le namespace de nom vide
→ ::X
On peut emboîter des namespace
Il est possible d’établir des alias de namespace :
namespace m = maths;
Bibliothèques Boost

Why should an organization use Boost ?




In a word, Productivity. Use of high-quality
libraries like Boost speeds initial development,
results in fewer bugs, reduces reinvention-of-thewheel, and cuts long-term maintenance costs. And
since Boost libraries tend to become de facto or de
jure standards, many programmers are already
familiar with them.
Utilisation intensive des templates
Plus de 80 bibliothèques : en général rien à
installer, prêt à l'utilisation
En partie intégré dans la norme C++2011
Bibliothèques Boost :
http://www.boost.org/doc/libs/1_54_0/









String and text processing : regexp ...
Containers : arbres, graphes ...
Iterators : extensions des itérateurs STL
Algorithms : géométrie, graphisme ...
Function Objects and higher-order
programming : lambda-fonctions …
Generic Programming : type traits ...
Template Metaprogramming
Preprocessor Metaprogramming
Concurrent Programming : framework MPL
Bibliothèques Boost :
http://www.boost.org/doc/libs/1_54_0/








Math and numerics : types et fonctions
Correctness and testing : monitoring, tests
unitaires
Image processing
Input/Output : sockets, sérialisation …
Inter-language support : interface avec
Python
Memory : smart pointers …
Parsing : analyseur LL(1)
Programming Interfaces : wrappers, callbacks
…

Modèles et STL

Transcription

Documents pareils

(Horaire publi\351 T16.xls)

BTS BioAnalyses et Contrôles et licence professionnelle Biologie

BacTechno STL - Les Sardières

Exercices d`entraînement sur les pourcentages :

Offre d`emploi - Chargé(e)

Sciences et Techniques de Laboratoire

promo 2007 D.s : IFSI Institut de Formation aux Soins Infirmiers

TABLE DES MATIÈRES Henri-Pierre Jeudy Transmettre, verbe

Bac STL - Lycée Jules HAAG

FERRÉ, FERRAT, FARRÉ