Hiver 2025

Programmation
avancée en C++
GIF-1003, IFT-1006

Thierry EUDE, ing., Ph.D.

Travail individuel
À rendre avant la date indiquée
sur le portail du cours
(Voir modalités de remise à la fin de l'énoncé)
Ce travail doit être de votre propre création.
Tout étudiant qui commet une infraction au Règlement
disciplinaire à l'intention des étudiants de l'Université Laval
dans le cadre du présent cours, notamment en matière de plagiat,
est passible des sanctions qui sont prévues dans ce règlement. Il
est très important pour tout étudiant de prendre connaissance des
articles 23 à 46 du Règlement disciplinaire. Celui-ci peut être
consulté à l'adresse suivante:
http://ulaval.ca/reglement-disciplinaire
Tout étudiant est tenu de respecter les règles relatives au plagiat.
De plus, les étudiants ou étudiantes ayant collaboré au plagiat
seront soumis aux sanctions normalement prévues à cet effet par
les règlements de l’Université.

Tous les travaux sont soumis à un logiciel de détection de

plagiat.

Travail Pratique #2
Hiérarchie de classes, contrat, test
unitaire, gestion mémoire

Faculté des sciences et de génie

Département d’informatique
et de génie logiciel
Notre objectif final est de construire un outil de gestion de comptes des clients d'une banque. La série
des travaux pratiques devrait tendre vers cet objectif. Chaque travail pratique constituera donc une des
étapes de la construction de cet outil.

But du travail
• Apprivoiser le processus de développement de plusieurs classes dans un environnement
d'implémentation structuré;
• Apprivoiser les concepts d’héritage et de polymorphisme.
• Utiliser un conteneur de STL.
• Respecter des normes de programmation et de documentation.
• Utiliser un outil de génération de documentation
• Optimiser son environnement de développement
• Utiliser la théorie du contrat et mettre en place les tests unitaires.
• Utiliser une hiérarchie de classes dans un programme minimaliste

Mise en place de la hiérarchie des comptes

Au sommet de la hiérarchie, la classe Compte sera utilisée. Cette classe est spécialisée par des types de
comptes différents. Le premier est Epargne, le second est Cheque, on pourra en imaginer d’autres dans
le futur :
Client Compte

1 * On se servira de cette
hiérarchie pour implémenter
le polymorphisme.
Epargne Cheque Hypotheque

Classe Compte
Cette classe permet de modéliser tous les types de comptes d’un client. Elle contient les attributs :
m_noCompte (doit être positif)
m_tauxInteret
m_solde
m_description
Un objet string (doit être non vide)
m_dateOuverture
la date à la création du compte
cette date est fixée à la construction du compte
La classe Compte comprend les méthodes suivantes:
Un constructeur de la classe. On construit un objet Compte à partir de données passées en paramètre.
Chacun de ces paramètres est considéré comme valide. Autrement, une erreur de contrat sera générée.
Pour déterminer les conditions préalables, voir la description des attributs.

Des méthodes d’accès en lecture aux attributs de la classe (accesseurs), ceci pour tous les attributs.

© 2025, T. Eude, Département d'informatique et de génie logiciel, Université Laval 2

Des méthodes permettant de changer le taux d’intérêt, le solde et la description du compte (ce sont les
seuls mutateurs de la classe).

La classe inclut également les méthodes suivantes:

virtual ~Compte (){} ;
Destructeur virtuel (voir manuel page 315 ou Penser en C++ - Bruce Eckel)

std::unique_ptr<Compte> clone() const

La déclaration de cette méthode doit imposer l’implémentation de celle-ci dans toute classe dérivée. Il
n’y a rien à définir dans la classe Personne pour cette méthode (voir classes dérivées).

double calculerInteret()
Cette méthode permet de calculer les intérêts d’un compte selon sa spécialisation. Toutefois, au niveau
de la classe Compte, elle retourne seulement 0 pour le cas où une classe dérivée ne présenterait pas de
spécialisation à ce niveau. La déclaration de cette méthode doit permettre un traitement polymorphe.

reqCompteFormate()
Cette méthode retourne dans un objet string les informations sur le compte dans le format suivant :

numero : 12345
Description : compte courant
Date d'ouverture : Jeudi le 30 janvier 2025
Taux d'interet : 0.2
Solde : 3000 $
Utilisez la classe ostringstream du standard pour formater les informations sur le compte. La
déclaration de cette méthode doit permettre un traitement polymorphe dans toute la hiérarchie de classe
et doit pouvoir être augmentée.

Classe Epargne
La classe Epargne représente les comptes dont les intérêts sont calculés en fonction du taux d’intérêt et
du solde. Le taux d’intérêt annuel minimum est de 0.1% et au maximum 3.5%.

Elle ne contient pas d’attribut spécifique, mais le solde doit être positif ou nul.
Il faut prévoir un constructeur avec paramètres. Ce constructeur doit permettre de construire un objet
valide à partir de données passées en paramètre. La description est "Epargne" par défaut, mais peut être
autre chose.

La classe inclut les méthodes suivantes :

calculerInteret()
calcule l’intérêt de la manière « simplifiée » suivante : solde multiplié par le taux d’intérêt (on
pourra envisager de faire mieux plus tard…).

std::unique_ptr<Compte> clone() const override

Celle-ci permet de faire une copie allouée sur le monceau de l'objet courant. Pour faire une copie, il s'agit
simplement de faire :
return make_unique<Epargne>(*this); // Appel du constructeur copie

© 2025, T. Eude, Département d'informatique et de génie logiciel, Université Laval 3

reqCompteFormate()
Cette méthode qui augmente la méthode reqCompteFormate de la classe de base Compte et qui retourne
dans un objet std::string les informations correspondant à un Compte formatées sous le format
suivant:
Compte Epargne
numero : 12345
Description : Etudes
Date d'ouverture : Jeudi le 30 janvier 2025
Taux d'interet : 0.3
Solde : 3000 $
Interet : 9$

Classe Cheque
La classe Cheque représente les comptes dont les intérêts sont calculés en fonction du nombre de
transactions et du taux d’intérêt. Elle contient les attributs :
m_nombreTransactions
m_tauxInteretMinimum

Un compte chèque ne peut pas avoir plus de 40 transactions.

Le taux d’intérêt minimum par défaut est de 0.1%.
La relation d’ordre entre le taux du compte et le taux d’intérêt minimum doit bien sûr être respectée.
La classe inclut les méthodes suivantes :
• Des accesseurs pour ses attributs spécifiques.
• Un mutateur pour pouvoir modifier le nombre de transactions
• Un constructeur avec paramètres. Par défaut la description devrait être "Cheque", mais peut être
autre chose. Ce constructeur doit permettre de construire un objet valide à partir de données
passées en paramètre. Si chacun de ces paramètres n’est pas considéré valide, une erreur de
contrat sera générée.
La classe inclut également les méthodes suivantes :
calculerInteret()
L’intérêt se calcule par le produit du solde par le taux d’intérêt, ceci sur un solde négatif (si le solde est
positif ou nul, il n’y a pas d’intérêt à payer) de la manière suivante :
- entre 0 et jusqu’à 10 transactions, l’intérêt est payé au taux d’intérêt minimum.
- de 11 jusqu’à 25 transactions, l’intérêt est payé au taux d’intérêt minimum plus 40%.
- de 26 jusqu’à 35 transactions, l’intérêt est payé au taux d’intérêt minimum plus 80%.
- au-delà de 35 transactions, l’intérêt est payé au taux d’intérêt du compte;
reqCompteFormate()
Cette méthode qui augmente la méthode reqCompteFormate de la classe de base Compte et qui retourne
dans un objet std::string les informations correspondant à un Compte formatées sous le format
suivant:
Compte Cheque
numero : 12345
Description : Mon compte courant
Date d'ouverture : Vendredi le 31 janvier 2025
Taux d'interet : 4.2
Solde : -3000 $
nombre de transactions : 4
Taux d'interet minimum : 0.3
Interet : 9 $

© 2025, T. Eude, Département d'informatique et de génie logiciel, Université Laval 4

std::unique_ptr<Compte> clone() const override
Celle-ci permet de faire une copie allouée sur le monceau de l'objet courant. Pour faire une copie, il s'agit
simplement de faire :
return make_unique< Cheque >(*this); // Appel du constructeur copie

Classe Client
La classe Client permet de faire la gestion des comptes.
Elle a pour attributs :
m_noFolio
Le numéro de folio du client. Doit être dans l’intervalle [1000, 10000[
m_nom
m_prenom
Le nom et le prénom du client. Doivent être dans un format valide tel que déterminé par la
fonction util ::validerFormatNom développée dans la première partie du projet (tp1).
m_telephone
Le numéro de telephone du client. Il ne doit pas être vide.
util::Date m_dateNaissance;
La date de naissance du client. Ne couvre que l’intervalle [1970, 2037].
Remarque : la classe Date incluant le contrat vous est fournie.

La classe Client doit contenir tous les comptes du client dans un conteneur de type « vector »:
std::vector<std::unique_ptr< Compte > m_comptes;
En fait, ce sont des pointeurs « intelligents » à Compte. Pour faire du polymorphisme en C++, il est
nécessaire d'avoir le pointeur sur un objet. Par ailleurs le recours à des « pointeurs intelligents » permet
de leur déléguer la responsabilité de la libération de la mémoire dans le cas d’allocations dynamiques.

La classe possède un constructeur. On construit un objet Client à partir de valeurs passées en paramètre.
Si chacun de ces paramètres n’est pas considéré comme valide, une erreur de contrat sera générée. Pour
déterminer les conditions préalables, voir la description des attributs. Attention, la Date de naissance doit
être passée en paramètre.
La classe inclut également les méthodes suivantes :
• Des accesseurs pour chacun des attributs (sauf m_comptes)
• Une méthode permettant de savoir combien de comptes possède le client
• Un opérateur de comparaison d’infériorité. La comparaison se fait sur la base du numéro de client.
void ajouterCompte (const Compte& p_nouveauCompte);
Cette méthode permet d’ajouter un compte au vecteur de comptes. La classe Client conserve des
pointeurs sur des comptes et elle est responsable de la gestion de la mémoire. Pour réaliser cet objectif,
le compte passé par référence constante est cloné et ajouté dans le vecteur. Les comptes ont une méthode
virtuelle clone() pour faire cela.
Exemple d'ajout d'un compte dans le vecteur :
m_comptes.push_back(p_nouveauCompte.clone());

reqClientFormate
Cette méthode retourne dans un objet std::string les informations correspondant à un client formatées
sous le format suivant :
Client no de folio : 5000
Joe BLO
Date de naissance : Samedi le 12 mai 1979
418 656-2131

© 2025, T. Eude, Département d'informatique et de génie logiciel, Université Laval 5

reqReleves()
Cette méthode parcourt tous les comptes du client et retourne dans une chaine de caractères
(string) les informations sur ceux-ci sous le format suivant :
Client no de folio : 5000
Joe BLO
Date de naissance : Samedi le 12 mai 1979
418 656-2131
Compte Cheque
numero : 10001
Description : courant
Date d'ouverture : Mercredi le 07 mars 2018
Taux d'interet : 1.2
Solde : 500 $
nombre de transactions : 4
Taux d'interet minimum : 0.3
Interet: 0 $
Compte Epargne
numero : 10007
Description : voyage
Date d'ouverture : Mercredi le 07 mars 2018
Taux d'interet : 1.25
Solde : 500 $
Interet : 6.25$

• La classe étant d’une forme de Coplien (voir module 5), il faut prévoir, un constructeur copie et
un opérateur d’assignation.

Théorie du contrat
Les classes doivent implanter la théorie du contrat en mettant les PRECONDITIONs,
POSTCONDITIONs et INVARIANTs aux endroits appropriés. Bien sûr, la méthode void
verifieInvariant() const doit être implantée pour vérifier les invariants. Voir l'exemple avec la
présentation de la théorie du contrat. Vous devez aussi déterminer les endroits où tester l'invariant de la
classe.
• Ajouter dans votre projet les fichiers ContratException.h et ContratException.cpp pour
implanter la théorie du contrat.

Test unitaire
Pour chaque classe, vous devez construire un test unitaire selon la méthode prescrite dans le cours en
vous appuyant sur la théorie du contrat. Les fichiers de test doivent s'appeler, pour respecter les normes :
CompteTesteur.cpp, EpargneTesteur.cpp, ChequeTesteur.cpp, ClientTesteur.cpp;

Documentation
Toutes les classes ainsi que toutes les méthodes devront être correctement commentées pour pouvoir
générer une documentation complète à l’aide de l’extracteur DOXYGEN. Des précisions sont fournies
sur le site Web pour vous permettre de l’utiliser (syntaxe et balises à respecter, etc.).
Vous devez respecter les normes de programmation adoptée pour le cours. Ces normes de programmation
sont à votre disposition dans la section "Notes de cours / Présentations utilisées en cours / Normes de
programmation en C++ " du site Web du cours.
© 2025, T. Eude, Département d'informatique et de génie logiciel, Université Laval 6
Aussi, vous devez « étendre » le namespace bancaire pour y inclure les classes nouvellement
développées. Les fonctions de validation doivent, quant à elles, être dans le namespace util

Utilisation
Après avoir implanté et testé les classes demandées, vous devez écrire un programme minimaliste qui
utilise Client avec les différents types de comptes.
Le programme commence par créer un client (les données nécessaires (numéro, nom, prénom, etc.) sont
demandées à l’usager).
Il est ensuite demandé à l’usager de saisir des informations pour créer puis ajouter successivement deux
nouveaux comptes (un compte Cheque et un compte Epargne).
Rappelons que le client ainsi que les comptes ne peuvent être construits qu’avec des valeurs valides.
C’est la responsabilité du programme principal qui les utilise de s’assurer que ces valeurs sont
valides. Les critères de validité ont été énoncés dans la description des attributs des classes.
Le relevé de compte du client est ensuite affiché. Voir l’exemple d’exécution fourni.

Modalités de remise, bien livrable

Le deuxième travail pratique pour le cours Programmation avancée en C++ est un travail individuel
Tous vos développements doivent être faits dans le dépôt github privé qui vous est créé après avoir
accepté « l’assignment »

On devra y retrouver des projets Netbeans complets et configurés tels que présentés en cours et en
laboratoire. Votre travail sera évalué dans la machine virtuelle fournie pour le cours.

Critères d'évaluation
1) Respect des biens livrables (très important!)
2) Respect des normes de programmation,
3) Documentation avec DOXYGEN
4) Structures, organisation du code (très important!)
En particulier :
• Organisation de l’espace de travail dans Netbeans
• Configuration de l’espace de travail (propriétés)
• Utilisation des outils recommandés (contrat, test unitaire)
• Adaptation de l’espace de travail (personnalisation)
5) Exactitude du code
6) Théorie du contrat et tests unitaires
7) Utilisation des classes, c.-à-d. le programme principal

Particularités du barème
• Si des pénalités sont appliquées, elles le sont sur l’ensemble des points.
• Si un travail comporte ne serait-ce qu'une erreur de compilation, il sera fortement pénalisé, et
peut même se voir attribuer la note zéro systématiquement.
• Il est très important que votre travail respecte strictement les consignes indiquées dans
l’énoncé, en particulier les prototypes des méthodes, les noms des fichiers et la structure de
développement sous Netbeans sous peine de fortes pénalités

© 2025, T. Eude, Département d'informatique et de génie logiciel, Université Laval 7