Packages, Exceptions et Autres

Dispensé par :
Jean Serge Dimitri Ouattara
jean.ouattara@ujkz.bf

Version 2022-2023
Packages, Erreurs et autres

1 Gestion d’exceptions

2 Gestion des espaces de noms namespace

3 Chaînes de caractères

4 Modèle (Template)
Packages, Erreurs et autres

1 Gestion d’exceptions

2 Gestion des espaces de noms namespace

3 Chaînes de caractères

4 Modèle (Template)
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Généralités 1

Qu’est-ce qu’une exception

Une exception est une interruption volontaire du programme
définie par le programmeur lors de l’écriture du code afin
d’éviter de tomber dans un bug.

Illustration

Procedure f()
Entier b; Fonction g(Entier t): Caractere *
Caractere *p; Caractere *p;
Pour b de 1 à 10 Faire p<--AlouerMemoire(t);
p<--g(b); Si (Echec dans Allocation) Alors
SI Exception(Allocation impossible) Alors Exception(Allocation impossible);
Afficher(Memoire non allouée); Fin Si
Retourner; Afficher(Allocation réussi);
FinException Retourner p;
Fin Pour
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Généralités 2

Etape de gestion d’une exception

Lorsqu’une exception se produit, l’exécution va remonter la
pile jusqu’à trouver un gestionnaire d’exception ;
Si aucun gestionnaire n’est trouvé, alors le programme se
termine ;
Les exceptions sont typées : une instance est associée au
déclenchement de l’exception et différents gestionnaires
doivent être écrits selon le type de l’exception.
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Lévée de l’exception

Lévée de l’exception avec throw

La levée d’une exception se fait grâce à throw :

char* g(int t){

char *p;
p=(char *) malloc(t*size(char));
if (p==null){
//Lévée d’exception
throw runtime_error("Erreur d’allocation");
}
cout << "Allocation réussie" << endl;
return p;
}
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Lévée de l’exception

Type d’exception avec throw

On peut utiliser les types d’exceptions suivants :
domain_error() : erreur de domaine mathématique ;
invalid_argument() : argument invalide ;
length_error() : taille invalide ;
out_of_range() : erreur d’indice ;
logic_error() : problème de logique ;
range_error() : erreur de plage ;
overflow_error() : erreur d’overflow ;
underflow_error() : erreur d’underflow ;
runtime_error() : autre erreur.
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Capture de l’exception

Capture de l’exception avec try ... catch

void f(){
int b; char *p;
for(b=0;b<10;b++){
try{// Partie pouvant lever l’exception
p=g(b);
}catch(exception const& e){ // capture de l’exception
//description de l’erreur
cerr << "ERREUR : " << e.what() << endl;
}
cout << " Terminé"<< endl;
}
}
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Capture de l’exception 1

Capture de l’exception avec try ... catch

L’exception est levée dans le bloc try ;
La gestion se fait dans la partie catch ;
e.what() retourne une valeur entre :
bad_alloc(erreur allocation) ;
bad_cast(erreur casting) ;
bad_exception(erreur non prise en compte) ;
bad_typeid(erreur typeid) ;
ios_base : :failure(erreur flux).
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Capture de l’exception 2

Plusieurs gestionnaires (catch)

Pour un bloc try, plusieurs gestionnaires peuvent être écrits :

try{
...
}catch(int i){
...
}catch(const char *){
...
}catch(...){
...
}

catch(...) capture tout autre exception : il doit venir en dernier.

Packages, Erreurs et autres

1 Gestion d’exceptions

2 Gestion des espaces de noms namespace

3 Chaînes de caractères

4 Modèle (Template)
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Généralités

Espace de noms
Un programme important utilise de nombreuses bibliothèques,
fonctions, etc. Pour éviter les conflits de noms, on utilise des
espaces de noms (namespace) :
on associe un nom à un ensemble de variables, types,
fonctions ;
Leur nom complet est : leur nom d’espace suivi de : : et de
leur nom. Par exemple la fonction int fct()... définie dans
l’espace de nom A aura pour nom complet A : :fct() ;
Les noms complets de cout et cin sont std : :cout et
std : :cin ;
Pour éviter d’écrire les noms complets , on utilise : using
namespace std ;
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Implémentation en C++

Création d’un namespace

namespace isge {
int NbEtudiants = 1000 ;
int CalculMoyenne(){
cout << "Moyenne... " ;
}
}

Si on n’utilise pas using namespace isge ; :

NbEtudiants s’écrit isge : :NbEtudiants ;
CalculMoyenne s’écrit isge : :CalculMoyenne.
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Namespace et classe

A.cpp
#include "A.hpp"
namespace tec {
A.hpp void A::m();
namespace tec { ...
class A { }
public: }
void m();
}; A.cpp version 2
} #include "A.hpp"
void tec::A::m();
...
}
Packages, Erreurs et autres

1 Gestion d’exceptions

2 Gestion des espaces de noms namespace

3 Chaînes de caractères

4 Modèle (Template)
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Un mot sur les chaînes de caractères

Informations sur les chaînes de caractères

En C++, on peut toujours utiliser le même mécanisme qu’en C
(char *) pour représenter les chaînes de caractères mais la
librairie standard de C++ propose son propre type std : :string
dont quelques avantages par rapport à char * sont :
avec string on bénéficie de nombreuses autres
fonctionnalités de la bibliothèque standard, ce qui n’est pas
le le cas de char * ;
string est plus rapide, plus lisible et plus sûr que char * ;
string contient aussi les fonctions sur les traitements des
chaînes de caractères de char * (strcm, strcpy, strlen, ...) et
beaucoup plus.
Packages, Erreurs et autres

1 Gestion d’exceptions

2 Gestion des espaces de noms namespace

3 Chaînes de caractères

4 Modèle (Template)
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Problématique

Problème
On a besoin d’une classe dont les méthodes effectuent les
mêmes opérations quel que soit le type des attributs. Par
exemple on suppose que Plus(a, b) fera :
somme de a et b si ce sont des nombres (entiers, réels) ;
concaténation de a et b si ce sont des chaînes de
caractères ;
OR (ou logique) de a et b si ce sont des booléens ;
...

Solution
La solution à ce genre de problème dans C++ est d’utiliser la
généricité et les templates.
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Comment faire ?

Mise en oeuvre dans les fonctions

On ne définit pas les types des paramètres et du retour de
la fonction ;
On utilise un type générique dans la définition de la
fonction ;
On ne précise les types qu’à l’appel de la fonction ; i.e.
qu’on peut avoir, pour chaque appel, des types différents.

Mise en oeuvre dans les classes

On ne définit pas les types des attributs et des méthodes ;
On utilise un type générique dans la classe ;
On ne précise les types qu’à l’instanciation de la classe ;
i.e. qu’on peut avoir, pour chaque objet, des types différents.
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Exemple Fonction générique

utilisation dans le main()

int main() {
cout << plus<int>(2, 3) << endl;
avant main() // affiche 5
template <typename T> cout << plus<double>(2.5, 3.5) << endl;
// affiche 6
T plus(T a,T b) {
cout << plus<string>("bon", "jour") << endl;
return a + b; // affiche bonjour
} cout << plus<bool>(true, false) << endl;
// affiche 1
return 0;
}
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Exemple Classe générique 1

Point.hpp : définition des méthodes obligatoires

#ifndef POINT_H
#define POINT_H
template <typename T>
class Point {
public:
Point(T abs, T ord): abs(abs), ord(ord){}
void setAbs(T abs){ this->abs = abs; }
void setOrd(T ord){ this->ord = ord; }
T getAbs() { return abs; }
T getOrd() { return ord; }
string toString () { return "(" + abs + ", " + ord + ")";}
private:
T abs; T ord;
};
#endif
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Exemple Classe générique 2

main correspondant
int main() {
Point<int> p1(2, 5);
cout << p1.toString() << endl;
// affiche (2, 5)
Point<float> p2(2.3, 5.8);
cout << p2.toString() << endl;
// affiche (2.300000, 5.800000)
return 0;
}

p1 et p2 sont deux objets différents grâce à l’utilisation de la

généricité.
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Outil de la généricité en C++ : STL

Généralités sur la STL

La STL (Standard Template Library) est une bibliothèque qui
permet d’avoir des structures de données génériques. Ainsi au
lieu d’utiliser les tableaux dynamiques ou les listes chaînées ou
les arbres, ... le développeur peut faciliment utiliser un outil
correspondant défini dans la STL. La STL est organisée en :
Structures de données pour représenter les données d’un
certain type (tableau d’entier, liste chaînées de chaînes de
caractères) ;
Itérateurs pour parcourir les collections ;
Algorithmes pour appliquer des traitements (recherche, tri,
...) aux collections.
Gestion d’exceptions Gestion des espaces de noms namespace Chaînes de caractères Modèle (Template)

Outil de la généricité en C++ : STL Exemple

UtilisationSTL.cpp
#include <vector>
#include <iostream>
#include <algorithm>
int main(void) {
int temp;
std::vector<int> collection;// structure de données
std::cout << "Entrer des entiers, entrer 0 pour arrêter!";
while(std::cin >> temp != 0) {
if(temp == 0) break;
collection.push_back(temp); // algorithme push_back
}
std::sort(collection.begin(), collection.end());// algorithmes
std::cout << "La version triée des entrées est : ";
for(std::vector<int>::iterator i=collection.begin(); i!=collection.end();
std::cout << i << std::endl;
}
}