Solutions Détaillées des Travaux
Pratiques C++
Ce document présente les solutions complètes pour les TP1 à TP5 du cours “Essentiels
en programmation C++”. Chaque exercice inclut le code source, une explication ligne
par ligne, ainsi que des suggestions de modifications.
TP1 : Gestion d’inventaire simple
Objectif
Créer un programme pour gérer un inventaire de produits (nom, quantité, prix) avec
sauvegarde dans un fichier.
Code Source
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;
struct Produit {
string nom;
int* quantite; // Utilisation d'un pointeur pour la quantité comme
demandé
double prix;
};
void sauvegarderInventaire(const vector<Produit>& inventaire) {
ofstream fichier("[Link]");
for (const auto& p : inventaire) {
fichier << [Link] << " " << *([Link]) << " " << [Link] << endl;
}
[Link]();
}
int main() {
vector<Produit> inventaire;
int choix;
do {
cout << "\n1. Ajouter Produit\n2. Afficher Min/Max\n3.
Sauvegarder\n4. Quitter\nChoix : ";
cin >> choix;
if (choix == 1) {
Produit p;
cout << "Nom : "; cin >> [Link];
[Link] = new int;
cout << "Quantite : "; cin >> *([Link]);
cout << "Prix : "; cin >> [Link];
inventaire.push_back(p);
} else if (choix == 2 && ![Link]()) {
Produit* maxP = &inventaire[0];
Produit* minP = &inventaire[0];
for (auto& p : inventaire) {
if ([Link] > maxP->prix) maxP = &p;
if ([Link] < minP->prix) minP = &p;
}
cout << "Plus cher : " << maxP->nom << " (" << maxP->prix << ")"
<< endl;
cout << "Moins cher : " << minP->nom << " (" << minP->prix <<
")" << endl;
}
} while (choix != 4);
// Libération mémoire
for (auto& p : inventaire) delete [Link];
return 0;
}
Explication ligne par ligne
1. struct Produit : Définit une structure regroupant les données d’un produit.
2. int* quantite : Pointeur vers un entier, respectant la consigne d’utiliser des
pointeurs pour les quantités.
3. ofstream fichier("[Link]") : Ouvre un flux de sortie pour écrire
dans le fichier spécifié.
4. *([Link]) : Déréférencement du pointeur pour accéder à la valeur réelle de
la quantité.
5. vector<Produit> inventaire : Tableau dynamique stockant les produits.
6. new int : Allocation dynamique de mémoire pour stocker la quantité d’un
nouveau produit.
7. delete [Link] : Libération cruciale de la mémoire allouée dynamiquement
pour éviter les fuites.
TP2 : Jeu du mot mystère avancé
Objectif
Deviner un mot dont les lettres ont été mélangées aléatoirement.
Code Source
#include <iostream>
#include <string>
#include <algorithm>
#include <ctime>
#include <fstream>
using namespace std;
string melangerLettres(string mot) {
string melange = mot;
random_shuffle([Link](), [Link]());
return melange;
}
void enregistrerScore(int essais) {
ofstream fichier("[Link]", ios::app);
fichier << "Essais : " << essais << endl;
[Link]();
}
int main() {
srand(time(0));
string motMystere, motSaisi;
cout << "Entrez le mot a deviner : ";
cin >> motMystere;
string motMelange = melangerLettres(motMystere);
int tentatives = 0;
do {
cout << "Quel est ce mot ? " << motMelange << endl;
cin >> motSaisi;
tentatives++;
if (motSaisi == motMystere) {
cout << "Bravo !" << endl;
enregistrerScore(tentatives);
} else {
cout << "Raté !" << endl;
}
} while (motSaisi != motMystere);
return 0;
}
Explication ligne par ligne
1. random_shuffle : Mélange les caractères de la chaîne de manière aléatoire.
2. srand(time(0)) : Initialise le générateur de nombres aléatoires avec l’heure
actuelle.
3. ios::app : Mode “append” pour ajouter le score à la fin du fichier sans effacer
l’existant.
4. do...while : Boucle qui s’exécute au moins une fois et continue tant que le mot
n’est pas trouvé.
TP3 : Mini-calculatrice scientifique
Objectif
Calculatrice avec menu, historique en tableau dynamique et sauvegarde.
Code Source
#include <iostream>
#include <vector>
#include <cmath>
#include <fstream>
using namespace std;
double addition(double a, double b) { return a + b; }
double racine(double a) { return sqrt(a); }
int main() {
vector<double> historique;
int choix;
double n1, n2, res;
while (true) {
cout << "1. Addition\n2. Racine\n3. Quitter\nChoix : ";
cin >> choix;
if (choix == 3) break;
cout << "Nombre : "; cin >> n1;
if (choix == 1) {
cout << "Nombre 2 : "; cin >> n2;
res = addition(n1, n2);
} else {
res = racine(n1);
}
cout << "Resultat : " << res << endl;
historique.push_back(res);
}
ofstream f("[Link]");
for (double r : historique) f << r << endl;
return 0;
}
Explication ligne par ligne
1. sqrt(a) : Fonction de la bibliothèque <cmath> pour calculer la racine carrée.
2. vector<double> historique : Stocke tous les résultats de la session.
3. break : Sort immédiatement de la boucle while .
TP4 : Gestion de notes d’étudiants
Objectif
Gérer les notes via un tableau dynamique 2D (pointeurs de pointeurs).
Code Source
#include <iostream>
#include <vector>
using namespace std;
int main() {
int nbE, nbM;
cout << "Nombre d'etudiants et de matieres : ";
cin >> nbE >> nbM;
// Tableau dynamique 2D
double** notes = new double*[nbE];
for(int i=0; i<nbE; ++i) notes[i] = new double[nbM];
for(int i=0; i<nbE; ++i) {
for(int j=0; j<nbM; ++j) {
cout << "Note E" << i+1 << " M" << j+1 << " : ";
cin >> notes[i][j];
}
}
// Calcul moyenne Etudiant 1 (exemple)
double somme = 0;
for(int j=0; j<nbM; ++j) somme += notes[0][j];
cout << "Moyenne E1 : " << somme/nbM << endl;
// Libération
for(int i=0; i<nbE; ++i) delete[] notes[i];
delete[] notes;
return 0;
}
Explication ligne par ligne
1. double** notes : Déclare un pointeur vers un pointeur, base d’un tableau 2D
dynamique.
2. new double*[nbE] : Alloue un tableau de pointeurs (les lignes).
3. new double[nbM] : Alloue chaque ligne (les colonnes).
4. delete[] : Libère la mémoire d’un tableau. Il faut libérer chaque ligne avant de
libérer le tableau de pointeurs.
TP5 : Mini-banque
Objectif
Gérer des comptes bancaires avec structures et pointeurs.
Code Source
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct Compte {
int numero;
string titulaire;
double solde;
};
void deposer(Compte* c, double montant) {
c->solde += montant;
}
int main() {
vector<Compte*> banque; // Tableau de pointeurs vers comptes
Compte* nouveau = new Compte{101, "Jean", 500.0};
banque.push_back(nouveau);
cout << "Solde avant : " << banque[0]->solde << endl;
deposer(banque[0], 200.0);
cout << "Solde apres : " << banque[0]->solde << endl;
delete nouveau;
return 0;
}
Explication ligne par ligne
1. Compte* c : Passage par pointeur pour modifier directement l’objet original.
2. c->solde : Opérateur flèche pour accéder aux membres d’une structure via un
pointeur.
3. vector<Compte*> : Stocke des adresses mémoire plutôt que les objets eux-
mêmes.
Modifications Express et Leurs Effets
Voici des modifications que vous pouvez apporter aux codes pour observer des
changements de comportement ou améliorer la robustesse.
TP Modification Effet sur le code
Simplifie la gestion mémoire. Plus
Remplacer int* quantite par int quantite
TP1 besoin de new ni de delete . Évite
(et adapter le code).
les risques de fuites mémoire.
Permet de détecter si le fichier
Ajouter if (!fichier.is_open()) avant [Link] ne peut pas être
TP1
d’écrire. créé (ex: dossier protégé), évitant un
crash silencieux.
random_shuffle est déprécié en
Utiliser std::shuffle avec un moteur C++ moderne. shuffle offre un
TP2
std::mt19937 au lieu de random_shuffle . mélange beaucoup plus
imprévisible et sécurisé.
Garantit que le mot mélangé ne soit
Ajouter motMelange == motMystere dans une
TP2 jamais identique au mot original, ce
boucle while .
qui rendrait le jeu inutile.
Empêche l’erreur fatale “Division
Ajouter une vérification if (n2 == 0) dans la
TP3 par zéro” qui fait planter le
division.
programme instantanément.
Formate les résultats financiers ou
Utiliser std::fixed et std::setprecision(2)
TP3 scientifiques pour n’afficher que
pour l’affichage.
deux chiffres après la virgule.
Gestion automatique de la
Remplacer les tableaux dynamiques new[] par mémoire. Plus besoin de delete[] .
TP4
std::vector<std::vector<double>> . Le code devient plus court et
beaucoup plus sûr.
Empêche un compte de devenir
Ajouter une condition if (montant > c-
TP5 négatif (découvert non autorisé),
>solde) dans la fonction retrait.
ajoutant une règle métier réaliste.
C++ moderne : le pointeur se détruit
Utiliser std::unique_ptr<Compte> au lieu de
TP5 tout seul quand il n’est plus utilisé.
Compte* .
Élimine manuellement les delete .
Conclusion
Ces exercices couvrent les bases essentielles du C++ : structures de données,
pointeurs, gestion dynamique de la mémoire et manipulation de fichiers. La maîtrise
de ces concepts est fondamentale pour passer à la programmation orientée objet.