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> POO en C++ © Jacques Farré UNS 2013 Généricité et STL 2/52 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 < b ? a : b; } instanciation explicite : float a, b; … b = min<float>(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) POO en C++ © Jacques Farré UNS 2013 Généricité et STL 3/52 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 < b ? a : b; comparaison des pointeurs ! } Spécialisation de min pour les char* template <> const char* min (const char* a, const char* b) { return strcmp (a, b) < 0 ? a : b; } POO en C++ © Jacques Farré UNS 2013 Généricité et STL 4/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 5/52 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) POO en C++ © Jacques Farré UNS 2013 Généricité et STL 6/52 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")); POO en C++ © Jacques Farré UNS 2013 Généricité et STL 7/52 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; POO en C++ © Jacques Farré UNS 2013 ne pas oublier l’espace, sinon opérateur >> Généricité et STL 8/52 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 = if (x < 0 || x >= Taille) throw BadIndex(); → erreur à la compilation return tab[x]; } const T& operator[] (int x) const { if (x < 0 || x >= Taille) throw BadIndex(); return tab[x]; } private: TypeElem tab[Taille]; }; POO en C++ © Jacques Farré UNS 2013 Généricité et STL 9/52 Modèles de classes et héritage Modèles et héritage sont complètement compatibles : soit class A {…}; template <typename T> class M {…}; – – – Modèle héritant d’un modèle template <typename T> class N : public M<T> {…}; modèle héritant d’une classe template <typename T> class P : public A {…}; classe héritant class B : public M<int> {…}; d’une instanciation et toute autre combinaison de modèle POO en C++ © Jacques Farré UNS 2013 Généricité et STL 10/52 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> POO en C++ © Jacques Farré UNS 2013 Généricité et STL 11/52 Modèles de classes et modèles d’opérateur Modèle d'opérateur et modèle de classe : template <int N, typename T> 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; } POO en C++ © Jacques Farré UNS 2013 Généricité et STL 12/52 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 template <int N, typename T> 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 template <int N, typename T> 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> POO en C++ © Jacques Farré UNS 2013 Généricité et STL 13/52 Modèles de classe et amitié Pour toutes les instanciations A<U> de template <typename T> class A { friend void F(int); friend void G(T x); // F(int) amie de toutes les A<U> // G(U x) (non template) amie de A<U> : friend void H<T>(T x); // H(U x>) (template) amie de A<U> : template <typename X> friend void P(X); // toute instanciation P(Y) est // amie de A<U> Analogue pour l’amitié entre classes POO en C++ © Jacques Farré UNS 2013 Généricité et STL 14/52 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 POO en C++ © Jacques Farré UNS 2013 template <typename T> class ptr { public : ptr (T* q = 0) : p (q) {} T& operator* const () { if (p == 0) throw NullPointer(); return *p; } private: T* p; }; Généricité et STL 15/52 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 -> }; template <typename T> 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; }; POO en C++ © Jacques Farré UNS 2013 Généricité et STL 16/52 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<B> pb; … pa = pb; un ptr<B> n'est pas un ptr<A> ⇒ définir un modèle de operator= POO en C++ © Jacques Farré UNS 2013 template <typename T> class ptr { public : ... template <typename U> ptr<T> operator= (ptr<U> q) { p = q.p; return *this; } erreur à la compilation private: si pas de conversion T* p; U* → T* }; Généricité et STL 17/52 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<B> pb; … pa = pb; un ptr<B> n'est pas un ptr<A> ⇒ définir un modèle de operator= ⇒ déclarer les ptr<U> amis des ptr<T> POO en C++ © Jacques Farré UNS 2013 template <typename T> class ptr { public : template<typename U> friend class ptr; ... template <typename U> ptr<T> operator= (ptr<U> q) { p = q.p; return *this; } mais ptr<U>.p private: privé pour ptr<T> T* p; ptr; → erreur à la compilation }; Généricité et STL 18/52 Modèles de classes (des pointeurs plus sûrs) Ptr<B> pb; Ptr<A> pa = pb; un ptr<B> n'est pas un ptr<A> ⇒ définir un modèle template <typename T> de constructeur class ptr { public : template<typename U> friend class ptr; ... class X {…}; template <typename U> class Y {…}; ptr (ptr<U> q) : p(q.p) {} class Z : public X {…}; private: T* p; }; erreur si pas de conversion U* → T* POO en C++ © Jacques Farré UNS 2013 ptr<Z> pz = new Z(…); ptr<Y> py = pz; // NON ptr<X> px = pz; // OK Généricité et STL 19/52 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] POO en C++ © Jacques Farré UNS 2013 Généricité et STL 20/52 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/ POO en C++ © Jacques Farré UNS 2013 Généricité et STL 21/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 22/52 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, … POO en C++ © Jacques Farré UNS 2013 Généricité et STL 23/52 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 POO en C++ © Jacques Farré UNS 2013 ofstream ostrstream Généricité et STL 24/52 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; POO en C++ © Jacques Farré UNS 2013 Généricité et STL 25/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 26/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 27/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 28/52 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))… POO en C++ © Jacques Farré UNS 2013 Généricité et STL 29/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 30/52 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) POO en C++ © Jacques Farré UNS 2013 Généricité et STL 31/52 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 POO en C++ © Jacques Farré UNS 2013 list Généricité et STL 32/52 Structures de données concrètes de 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(); } POO en C++ © Jacques Farré UNS 2013 Généricité et STL 33/52 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) POO en C++ © Jacques Farré UNS 2013 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) Généricité et STL 34/52 Structures de données concrètes de la STL Structures associatives concrètes (partiel) Simple AC Pair AC Sorted AC Unique AC set POO en C++ © Jacques Farré UNS 2013 map Généricité et STL 35/52 Structures de données concrètes de 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 36/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 37/52 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; POO en C++ © Jacques Farré UNS 2013 Généricité et STL 38/52 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() POO en C++ © Jacques Farré UNS 2013 ++ -- s.rbegin() Généricité et STL 39/52 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) {} }; POO en C++ © Jacques Farré UNS 2013 Généricité et STL 40/52 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); POO en C++ © Jacques Farré UNS 2013 Généricité et STL 41/52 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)); POO en C++ © Jacques Farré UNS 2013 Généricité et STL 42/52 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… POO en C++ © Jacques Farré UNS 2013 Généricité et STL 43/52 Programmer « sans boucles » Affichage d’une structure de données template <typename T> 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; } POO en C++ © Jacques Farré UNS 2013 Généricité et STL 44/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 45/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 46/52 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 (…); POO en C++ © Jacques Farré UNS 2013 Généricité et STL 47/52 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; POO en C++ © Jacques Farré UNS 2013 Généricité et STL 48/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 49/52 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 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 50/52 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 … POO en C++ © Jacques Farré UNS 2013 Généricité et STL 51/52 POO en C++ © Jacques Farré UNS 2013 Généricité et STL 52/52