POO C++ TD4: Héritage

Ce TP porte sur l'héritage en programmation orientée objet en C++. Il propose plusieurs exercices permettant de définir des classes de base et des classes dérivées, d'implémenter des méthodes redéfinies et de manipuler les attributs protégés et privés. Ce TP nécessite un environnement de développement C++ avec la possibilité de compiler et d'exécuter des programmes simples.

Objectifs

• Définir des classes de base et des classes dérivées en C++.
• Utiliser l'héritage pour partager et spécialiser des comportements.
• Implémenter des méthodes redéfinies (override) dans les classes dérivées.
• Manipuler les attributs privés et protégés.
• Tester les classes par des programmes principaux simples.

Prérequis et installation

• Connaissances de base en programmation C++ (classes, objets, méthodes).
• Compréhension du concept d'héritage en POO.
• Environnement de développement C++ avec support de la bibliothèque standard.
• Compilateur C++ compatible avec les standards classiques (ex : g++, clang++).

Exercice : Forme (Rectangle et Carré)

Dans cet exercice, vous devez définir deux classes : Rectangle et Carre. Le but est de corriger un programme donné qui utilise ces classes.

Le programme donné est :

#include <iostream.h>
int main()
{
  Rectangle R;
  Carre c1,c2(13.0,14.0);
  R.Longueur = 10.5;
  R.Largeur = 11.2;
  c1.Longueur = 22.0;
  c1.Largeur = 22.0;
  cout << c1.aire();
  R.changer_cote(32.0);
  cout << c1.perimetre();
  cout << R.perimetre();
  return 0;
}

Vous devez :

• Définir la classe Rectangle avec au moins les attributs Longueur et Largeur, ainsi que les méthodes aire(), perimetre() et changer_cote(double).
• Définir la classe Carre qui hérite de Rectangle, en s'assurant que les longueurs des côtés restent égales.
• Corriger les erreurs de compilation et d'exécution du programme principal.

Un résultat correct affichera l'aire et les périmètres calculés sans erreurs.

Exercice : Article et ArticleEnSolde

Vous devez créer une classe de base Article avec deux champs privés :

• Nom : chaîne de caractères (string)
• Prix : nombre à virgule flottante (double)

Les opérations à implémenter sont :

• GetPrix() : retourne le prix de l'article.
• SetPrix(double) : modifie le prix de l'article.
• Afficher() : affiche le prix de l'article.

Ensuite, créez une classe dérivée ArticleEnSolde qui ajoute :

• Remise : pourcentage de réduction sur le prix d'origine.
• SetRemise(int) : modifie le pourcentage de remise.

Cette classe doit redéfinir :

• GetPrix() pour retourner le prix après remise.
• Afficher() pour afficher aussi le pourcentage de remise.

Le but est de comprendre la redéfinition de méthodes dans une classe dérivée.

Exercice : Banque (Compte bancaire)

Vous devez définir trois classes :

• Compte bancaire (classe de base) avec :
• Attributs protégés : numéro du compte (long), solde (double).
• Méthodes publiques :
1. Ajouter() : ajoute de l'argent au compte.
2. Retirer() : retire de l'argent du compte.
3. Afficher() : affiche les caractéristiques du compte.

CompteEpargne (hérite de Compte bancaire) :

• Solde minimal : 5 dinars.
• Attribut : taux d'intérêt annuel.
• Méthode pour calculer l'intérêt annuel.

CompteCourant (hérite de Compte bancaire) :

• Solde minimal : -500 dinars (seuil négatif autorisé).

Vous devez définir ces classes et tester leurs fonctions dans un programme principal.

Exercice : Véhicule, Voiture et Avion

Définissez une classe Vehicule avec les attributs :

• Marque
• Date d'achat
• Prix d'achat
• Prix courant

Implémentez :

1. Un constructeur prenant en paramètre la marque, la date d'achat et le prix d'achat. Le prix courant sera calculé plus tard.
2. Une méthode Afficher() qui affiche l'état complet de l'instance.

Définissez ensuite deux classes dérivées :

• Voiture avec les attributs supplémentaires :
• Cylindrée
• Nombre de portes
• Puissance
• Kilométrage
• Avion avec les attributs supplémentaires :
• Type (hélices ou réaction)
• Nombre d'heures de vol

Pour chaque classe dérivée, définissez un constructeur initialisant tous les attributs et une méthode Afficher() qui utilise la méthode parente.

Ajoutez une méthode void calculePrix(int anneActuelle) dans la classe Vehicule qui calcule le prix courant :

Prix courant = prix d'achat - 1% par année écoulée depuis la date d'achat.

Redéfinissez cette méthode dans les classes Voiture et Avion :

• Pour une voiture :
• Prix courant = prix d'achat - 2% par année écoulée - 5% par tranche de 10 000 km parcourus.
• Si la marque est "Renault" ou "Fiat", soustraire 10% supplémentaires.
• Si la marque est "Ferrari" ou "Porsche", soustraire 20% supplémentaires.
• Pour un avion :
• Si avion à réaction : soustraire 10% par tranche de 1000 heures de vol.
• Si avion à hélices : soustraire 10% par tranche de 100 heures de vol.
• Le prix courant ne peut pas être négatif, s'il l'est, le fixer à 0.

Résultats attendus

• Les classes Rectangle et Carre doivent permettre de calculer correctement l'aire et le périmètre, avec les côtés du carré toujours égaux.
• La classe ArticleEnSolde doit retourner un prix ajusté selon la remise et afficher le pourcentage de réduction.
• Les classes CompteEpargne et CompteCourant doivent respecter leurs contraintes de solde minimal et permettre l'ajout, le retrait et l'affichage corrects.
• Les classes Vehicule, Voiture et Avion doivent afficher correctement leurs attributs et calculer le prix courant selon les règles données.
• Les méthodes redéfinies doivent produire des résultats cohérents avec les critères spécifiques à chaque classe dérivée.

Pièges courants

• Ne pas respecter la visibilité des attributs (privé, protégé) peut empêcher l'héritage correct.
• Oublier de redéfinir les méthodes dans les classes dérivées ou de les appeler correctement dans les constructeurs.
• Dans la classe Carre, ne pas forcer l'égalité des côtés peut conduire à des incohérences.
• Pour le calcul du prix courant, ne pas appliquer les pourcentages cumulés correctement ou oublier de vérifier que le prix ne devienne pas négatif.
• Dans la gestion des comptes bancaires, ne pas respecter les seuils minimaux peut fausser les résultats.
• Utiliser #include <iostream.h> est obsolète ; préférez #include <iostream> et std::cout.