Université Abdelmalek Essaadi

Faculté ses Sciences et techniques de Tanger

Département Génie Informatique
Cycle Licence: LST GI
POO C ++
Pr . ELAACHAk LOTFI
Pr . Ben abdel ouahab Ikram

Module : GI-51 Programmation

Orientée Objet en C++

Licence Génie Informatique 2022-2023

Partie 2:
Programmation Orientée Objet

1. Templates
2. STL

2
C++ Templates
• Une Template est une fonctionnalité puissante ajoutée en C++.

• Il permet de définir des classes et des fonctions génériques et fournit ainsi un support pour la programmation
générique.

• La programmation générique est une technique où les types génériques sont utilisés comme paramètres dans
les algorithmes afin qu’ils puissent fonctionner pour une variété de types de données.

• Les templates peuvent être représentés de deux manières :

• template de fonction

• template de classe

3
Template de fonction C++

• Les fonctions génériques définissent un ensemble d’opérations qui peuvent être appliquées aux différents
types de données.

• Le type des données sur lesquelles la fonction opérera dépend du type des données passées en paramètre.

• Une fonction générique est créée à l’aide du mot-clé template.

• La template définit exactement ce qu’une fonction fera.

4
Syntaxe de Template de fonction
#include <iostream>
using namespace std;

template<class T> T add(T &a, T &b) {

T result = a+b;
return result;
} int add(int &a, int &b) {
int result = a+b;
int main() {
int i =2;
return result;
int j =3; }
float m = 2.3;
float n = 1.2;
cout<<"Addition of i and j is :"<<add(i,j);
float add(float &a, float &b) {
cout<<'\n'; float result = a+b;
cout<<"Addition of m and n is :"<<add(m,n); return result;
return 0;
}
}
5
Templates de fonction avec plusieurs paramètres

float float
#include <iostream>
using namespace
intstd; int

template<class X,class Y> void fun(X a,Y b) {

std::cout << "Value of a is : " <<a<< std::endl;
std::cout << "Value of b is : " <<b<< std::endl;
}
int main() {
fun(15,12.3);
return 0;
}

6
Template de Classe C++

• Le modèle de classe peut également être défini de la même manière que le modèle de fonction.

• Lorsqu’une classe utilise le concept de modèle, alors la classe est appelée classe générique.

7
Template de Classe : syntaxe
#include <iostream>
using namespace std;

Template <class T> class A {

public:
T num1 = 5;
T num2 = 6;
void add() {
std::cout << "Addition of num1 and num2 : " << num1+num2 << std::endl;
}
};
int main() {
A<int> d;
d.add();
return 0;
}

8
Template de Classe Multiparamètres
#include <iostream>
using namespace std;
template <class T1, class T2>
class A {
T1 a;
T2 b;
public:
A(T1 x,T2 y) {
a = x;
b = y;
}
void display() {
std::cout << "Values of a and b are : " << a<<" ,"<<b<<std::endl;
}
};
int main() {
A<int,float> d(5,6.5);
d.display();
return 0;
}
9
 STL in C++
STL (Standard Template Library :
bibliothèque de modèles standard)

10
Les conteneurs STL
• Les conteneurs peuvent être décrits comme les objets qui contiennent les données du même type.

• Les conteneurs sont utilisés pour implémenter différentes structures de données, par exemple des tableaux,
des listes, des arbres, etc.

• Différents types de conteneurs :

• Conteneurs de séquence

• Conteneurs associatifs

• Conteneurs dérivés

11
Les vecteurs

• Un vecteur est une classe conteneur de séquences qui implémente un tableau dynamique, ce qui signifie que
la taille change automatiquement lors de l’ajout d’éléments.

• Un vecteur stocke les éléments dans des emplacements de mémoire contigus et alloue la mémoire selon les
besoins au moment de l’exécution.

• Un tableau suit une approche statique, cela signifie que sa taille ne peut pas être modifiée pendant l’exécution
tandis que le vecteur implémente un tableau signifie qu’il se redimensionne automatiquement lors de l’ajout
d’éléments.

12
Les vecteurs
Certaines fonctions associées au vecteur sont :
• begin() – Renvoie un itérateur pointant sur le premier élément du vecteur
• end() – Renvoie un itérateur pointant sur l’élément théorique qui suit le dernier élément du vecteur
• rbegin() – Renvoie un itérateur inverse pointant sur le dernier élément du vecteur (début inverse). Il passe du
dernier au premier élément
• rend() – Renvoie un itérateur inverse pointant sur l’élément théorique précédant le premier élément du
vecteur (considéré comme la fin inverse)
• cbegin() – Renvoie un itérateur constant pointant sur le premier élément du vecteur.
• cend() – Renvoie un itérateur constant pointant sur l’élément théorique qui suit le dernier élément du vecteur.
• crbegin() – Renvoie un itérateur inverse constant pointant sur le dernier élément du vecteur (début inverse). Il
passe du dernier au premier élément
• crend() – Renvoie un itérateur inverse constant pointant sur l’élément théorique précédant le premier élément
du vecteur (considéré comme une extrémité inverse)
13
 Les vecteurs
#include<iostream>
#include<vector>
using namespace std;

int main() {
vector<string> v1;
Déclaration
v1.push_back("javaTpoint ");
d’un vecteur de
type int v1.push_back("tutorial"); Ajoute un nouvel
For ( vector<string>::iterator itr=v1.begin(); itr!=v1.end(); ++itr) élément à la fin
du vecteur, après
cout<<*itr;
son dernier
Return 0; élément actuel.
}
14
Exemple d’un vector d’entiers

15
 #include <iostream>
#include <vector>
Initialiser un vecteur using namespace std;

Déclaration d’un vecteur de type int int main() {

vector<int> vec;
vec.push_back(1);
Remplir le vecteur élément par élément vec.push_back(2);
vec.push_back(3);
vec.push_back(4);
vec.push_back(5);
vec.push_back(6);
vec.push_back(7);
vec.push_back(8);
vec.push_back(9);
vec.push_back(101);
Afficher les éléments du vecteur en
for (int i = 0; i < vec.size(); i++) {
utilisant la boucle for
cout << vec[i] << " ";
}
return 0;
}
16
 Les vecteurs
#include <iostream>
#include <vector>
using namespace std;
int main() {
Déclaration et initialisation d’un vecteur de
vector<int> vectr{9,8,7,6,5,4,3,2,1,0};
type <int> avec les valeurs données
for (int i = 0; i < vectr.size(); i++) {
cout << vectr[i] << " \n";
Afficher les éléments du vecteur en utilisant la
boucle for }
return 0;
}

17
Les Listes
• List est un conteneur non-contigu tandis que vector est un conteneur contigu, c’est-à-dire que la liste stocke
les éléments sur une mémoire non-contiguë et vector stocke sur une mémoire contiguë.

• Les éléments ne sont pas rangés les uns à côté des autres dans la mémoire. Chaque « case » contient un
élément et un pointeur sur la case suivante, située ailleurs dans la mémoire

18
Les Listes
• L'avantage de cette structure de données est que l'on peut facilement ajouter des éléments au milieu. Il n'est
pas nécessaire de décaler toute la suite.

• L’inconvénient est qu’on ne peut pas directement accéder à une case donnée… tout simplement parce qu'on
ne sait pas où elle se trouve dans la mémoire. On est obligé de suivre toute la chaîne des éléments. Pour aller à
la huitième case, il faut aller à la première case, suivre le pointeur jusqu'à la deuxième, suivre le pointeur
jusqu'à la troisième et ainsi de suite jusqu'à la huitième. C'est donc très coûteux.

19

Les Listes
#include <iostream>
#include <list>
#include <iterator>
using namespace std;
//function for printing the elements in a list
void showlist(list <int> g){
list <int> :: iterator it;
for(it = g.begin(); it != g.end(); ++it)
cout << '\t' << *it;
cout << '\n';
} cout << "\ngqlist1.reverse() : ";
int main() {
list <int> gqlist1, gqlist2;
for (int i = 0; i < 10; ++i) {
gqlist1.push_back(i * 2);
gqlist2.push_front(i * 3);
} return 0;
cout << "\nList 1 (gqlist1) is : ";
showlist(gqlist1);
cout << "\nList 2 (gqlist2) is : ";
showlist(gqlist2);
list.front(): retourne la première valeur de la liste
list.back(): retourne la dernière valeur de la liste cout << "\ngqlist1.front() : " << gqlist1.front();
cout << "\ngqlist1.back() : " << gqlist1.back();
Supprime le premier élément de la liste et cout << "\ngqlist1.pop_front() : ";
décrémente la taille de la liste
gqlist1.pop_front();
À l’aide l’un objet
showlist(gqlist1);
iterator, on va parcourir
la liste du début jusqu’à
Supprime le dernier élément de la liste et cout << "\ngqlist2.pop_back() : ";
la fin décrémente la taille de la liste
gqlist2.pop_back();
showlist(gqlist2);
Inverse les éléments de la liste
gqlist1.reverse();
showlist(gqlist1);
Remplir lesles
deux listes de la liste par ordre croissant cout << "\ngqlist2.sort(): ";
Trie éléments
gqlist2.sort();
push_back(): ajouter l’élement à la fin de la liste
push_front(): ajouter l’élément au début de la liste showlist(gqlist2);
} 20
 Liste Personnes
#include <iostream>
#include <list>
using namespace std;

class Personne {
public :
string nom;
Définition de la Classe
int age ;
Personne
public :
Personne(string nom , int age ){
this->nom = nom ;
this->age = age; Remplir la liste avec des objets
} de la classe Personne
};
Déclaration d’une liste de type
int main() { push_back() : ajouter à la fin de
Personne
list<Personne> data; la liste
data.push_back(Personne(“personneX" , 12 ));
data.push_back(Personne(“personneY" , 15 ));
std::list<Personne>::iterator it;
for (it = data.begin(); it != data.end(); ++it){ Parcourir la liste avec un
std::cout << it->nom; iterateur pour afficher l’attribut
} ‘Nom‘ de chaque objet Personne
return 0; de la liste
} 21
Les Sets

• Les Sets sont un type de conteneurs associatifs dans lesquels chaque élément doit être unique, car la valeur de
l’élément l’identifie.

• La valeur de l’élément ne peut pas être modifiée une fois qu’il est ajouté à l’ensemble, bien qu’il soit possible
de supprimer et d’ajouter la valeur modifiée de cet élément.

• L'application des ensembles se fait principalement dans les arbres de recherche binaires.

• Dans les sets, on accède aux éléments à l'aide d'une clé qui est identifiée.

22
Les Sets

• Quelques fonctions de base associées à Set :

• begin() – Renvoie un itérateur au premier élément de l’ensemble.

• end() – Renvoie un itérateur à l’élément théorique qui suit le dernier élément de l’ensemble.

• size() – Renvoie le nombre d’éléments dans l’ensemble.

• max_size() – Renvoie le nombre maximum d’éléments que l’ensemble peut contenir.

• empty() – Retourne si l’ensemble est vide.

23
 cout << endl;
Les Sets // assigning the elements from s1 to s2
set<int> s2(s1.begin(), s1.end());
// print all elements of the set s2
#include <iostream> cout << "\nThe set s2 after assign from s1 is : \n";
#include <iterator> for (itr = s2.begin(); itr != s2.end(); itr++) {
#include <set> cout << *itr<<" ";
using namespace std; }
int main() { cout << endl;
// empty set container
set<int, greater<int> > s1; // remove all elements up to 30 in s2
// insert elements in random order cout << "\ns2 after removal of elements less than 30 :\n";
s1.insert(40); s2.erase(s2.begin(), s2.find(30));
s1.insert(30); for (itr = s2.begin(); itr != s2.end(); itr++) {
s1.insert(60); // lower bound and upper bound for set s1
cout <<*itr<<" "; cout << "s1.lower_bound(40) : \n"
s1.insert(20); }
s1.insert(50); << *s1.lower_bound(40)
// only one 50 will be added to the set << endl;
// remove element with value 50 in s2 cout << "s1.upper_bound(40) : \n"
s1.insert(50); int num;
s1.insert(10); << *s1.upper_bound(40)
num = s2.erase(50); << endl;
// printing set s1 cout << "\ns2.erase(50) : ";
set<int, greater<int> >::iterator itr; // lower bound and upper bound for set s2
cout << num << " removed\n"; cout << "s2.lower_bound(40) :\n"
cout << "\nThe set s1 is : \n"; for (itr = s2.begin(); itr != s2.end(); itr++) {
for (itr = s1.begin(); itr != s1.end(); itr++) { << *s2.lower_bound(40)
cout <<*itr<<" "; << endl;
cout << *itr<<" "; }
} cout << "s2.upper_bound(40) : \n"
cout << endl; << *s2.upper_bound(40)
<< endl;
return 0;
} 24
Les Maps
• Les maps sont des conteneurs associatifs qui stockent des éléments de manière mappée. Chaque élément a une
valeur clé et une valeur mappée. Deux valeurs mappées ne peuvent pas avoir les mêmes valeurs de clé.

• Quelques fonctions de base associées à Map :

• begin() – Renvoie un itérateur au premier élément de la carte
• end() – Renvoie un itérateur à l’élément théorique qui suit le dernier élément de la carte
• size() – Renvoie le nombre d’éléments dans la carte
• max_size() – Renvoie le nombre maximum d’éléments que la carte peut contenir
• empty() – Retourne si la carte est vide
• pair insert(keyvalue, mapvalue) – Ajoute un nouvel élément à la carte
• erase(iterator position)- Supprime l’élément à la position pointée par l’itérateur
• erase (const g) - Supprime la valeur de la clé ’g’ de la carte
• clear() – Supprime tous les éléments de la carte
25

Maps
#include <iostream>
#include <iterator>
#include <map>
using namespace std;
int main() {
// empty map container
map<int, int> gquiz1;
// insert elements in random order
gquiz1.insert(pair<int, int>(1, 40));
gquiz1.insert(pair<int, int>(2, 30));
gquiz1.insert(pair<int, int>(3, 60));
gquiz1.insert(pair<int, int>(4, 20));
gquiz1.insert(pair<int, int>(5, 50));
gquiz1.insert(pair<int, int>(6, 50));
gquiz1.insert(pair<int, int>(7, 10));
// printing map gquiz1
map<int, int>::iterator itr;
cout << "\nThe map gquiz1 is : \n";
cout << "\tKEY\tELEMENT\n";
for (itr = gquiz1.begin(); itr != gquiz1.end(); ++itr) {
cout << '\t' << itr->first
<< '\t' << itr->second << '\n';
} cout << "\tELEMENT = "
cout << endl;
// assigning the elements from gquiz1 to gquiz2
map<int, int> gquiz2(gquiz1.begin(), gquiz1.end());
// print all elements of the map gquiz2
cout << "\nThe map gquiz2 after"
<< " assign from gquiz1 is : \n";
cout << "\tKEY\tELEMENT\n";
for (itr = gquiz2.begin(); itr != gquiz2.end(); ++itr) { // remove all elements with key = 4
cout << '\t' << itr->first int num;
<< '\t' << itr->second << '\n'; num = gquiz2.erase(4);
} cout << "\ngquiz2.erase(4) : ";
cout << endl; cout << num << " removed \n";
// remove all elements up to cout << "\tKEY\tELEMENT\n";
// element with key=3 in gquiz2 for (itr = gquiz2.begin(); itr != gquiz2.end(); ++itr) {
cout << "\ngquiz2 after removal of" cout << '\t' << itr->first
" elements less than key=3 : \n"; << '\t' << itr->second << '\n';
cout << "\tKEY\tELEMENT\n"; }
gquiz2.erase(gquiz2.begin(), gquiz2.find(3)); cout << endl;
for (itr = gquiz2.begin(); itr != gquiz2.end(); ++itr) { // lower bound and upper bound for map gquiz1 key = 5
cout << '\t' << itr->first cout << "gquiz1.lower_bound(5) : "
<< '\t' << itr->second << '\n'; << "\tKEY = ";
} cout << gquiz1.lower_bound(5)->first << '\t';
cout << "\tELEMENT = "
<< gquiz1.lower_bound(5)->second << endl;
cout << "gquiz1.upper_bound(5) : "
<< "\tKEY = ";
cout << gquiz1.upper_bound(5)->first << '\t';
<< gquiz1.upper_bound(5)->second << endl;
return 0;
} 26
27
28
29
Documentation C++

cplusplus.com/reference/

30