Question de Cours & code 5 pts
1. **Héritage** : L'héritage est un concept de la programmation orientée objet où une classe (appelée classe dérivée ou sous-classe) peut hériter des attributs et des méthodes d'une autre classe (appelée classe de base ou classe mère). Cela permet de créer une relation "est-un" entre les classes, où la classe dérivée est une version spécialisée de la classe de base.
2. **Classe mère** : Aussi appelée classe de base ou classe parent, une classe mère est une classe à partir de laquelle d'autres classes, appelées classes dérivées, héritent des attributs et des méthodes.
3. **Objet composite** : Un objet composite est un objet qui contient d'autres objets comme ses membres. Ces objets peuvent être d'autres instances de classes ou de types de données simples. L'idée est que l'objet composite agit comme une seule entité, mais il est composé de plusieurs parties.
4. Une classe abstraite est une classe qui ne peut pas être instanciée directement, ce qui signifie qu'aucun objet concret ne peut être créé à partir de cette classe. Elle est conçue pour être une classe de base à partir de laquelle d'autres classes peuvent être dérivées. Par exemple, si nous avons une classe abstraite `Forme`, nous ne pouvons pas créer un objet directement de cette classe, mais nous pouvons créer des objets de ses sous-classes telles que `Cercle` ou `Rectangle`.
5. La différence fondamentale entre une instance, une classe et les méthodes est la suivante :
- **Instance** : Une instance est un objet concret créé à partir d'une classe. Chaque instance possède ses propres attributs distincts et peut exécuter les méthodes définies dans sa classe.
- **Classe** : Une classe est un modèle ou un plan pour créer des objets. Elle définit les attributs et les méthodes communes à toutes ses instances.
- **Méthodes** : Les méthodes sont des fonctions définies à l'intérieur d'une classe qui peuvent être appelées pour effectuer des actions sur les objets de cette classe. Les méthodes définissent le comportement des objets de la classe.
6. Le contenu de l'interface de classe, également connu sous le nom de fichier d'en-tête, comprend généralement :
- Déclarations de variables membres (attributs).
- Déclarations de méthodes membres.
- Déclarations de méthodes virtuelles pour une classe abstraite.
- Déclarations de constructeurs et de destructeurs.
- Directives de préprocesseur pour éviter les inclusions multiples.
7. Voici une implémentation de la fonction `sous_chaine` qui retourne TRUE si `sc` est une sous-chaîne de `chaine`, sinon FALSE :
#include <cstring> // Inclut la bibliothèque <cstring> pour utiliser la fonction strlen()
// Définition de la fonction sous_chaine qui vérifie si sc est une sous-chaîne de chaine
bool sous_chaine(const char* sc, const char* chaine) {
int len_sc = strlen(sc); // Calcule la longueur de la sous-chaîne sc
int len_chaine = strlen(chaine); // Calcule la longueur de la chaîne chaine
// Boucle sur chaque position possible de début de la sous-chaîne dans chaine
for (int i = 0; i <= len_chaine - len_sc; ++i) {
bool match = true; // Initialise un booléen pour indiquer si la sous-chaîne correspond
// Boucle sur chaque caractère de la sous-chaîne sc
for (int j = 0; j < len_sc; ++j) {
// Vérifie si les caractères correspondants de chaine et sc sont identiques
if (chaine[i + j] != sc[j]) {
match = false; // Si un caractère diffère, définir match sur false
break; // Sort de la boucle interne
}
}
if (match) { // Si match est toujours true après avoir parcouru toute la sous-chaîne
return true; // La sous-chaîne sc a été trouvée dans chaine, retourne true
}
}
// Si la boucle externe se termine sans retourner true, la sous-chaîne n'a pas été trouvée
return false; // Retourne false
}
Problème 15 pts
A)------------
#ifndef PRODUIT_H
#define PRODUIT_H
#include <string>
class Produit {
private:
std::string libelle;
int prixUnitaire;
public:
int code;
Produit(int code, std::string libelle, int prixUnitaire);
Produit(const Produit& p);
~Produit();
std::string getLibelle();
void setLibelle(std::string libelle);
int getPrixUnitaire();
void setPrixUnitaire(int prixUnitaire);
void affichage();
int operator==(const Produit& p);
static Produit lire_clavier();
static int montant(const Produit tab[], int taille);
};
#endif // PRODUIT_H
B)-----
#include "produit.h"
#include <iostream>
#include <string> // Inclure la bibliothèque pour utiliser les objets string
using namespace std;
Produit::Produit(int code, string libelle, int prixUnitaire) {
this->code = code;
this->libelle = libelle;
this->prixUnitaire = prixUnitaire;
}
Produit::Produit(const Produit& p) {
this->code = p.code;
this->libelle = p.libelle;
this->prixUnitaire = p.prixUnitaire;
}
Produit::~Produit() {
cout <<"Destruction de l'objet" <<endl;
}
string Produit::getLibelle() {
return libelle;
}
void Produit::setLibelle(string libelle) {
this->libelle = libelle;
}
int Produit::getPrixUnitaire() {
return prixUnitaire;
}
void Produit::setPrixUnitaire(int prixUnitaire) {
this->prixUnitaire = prixUnitaire;
}
void Produit::affichage() {
cout << "Produit [ Code " << code << ", Libelle " << libelle << ", Prix Unitaire " << prixUnitaire << "]." << endl;
}
int Produit::operator==(const Produit& p) {
if(this->code == p.code){
return TRUE;
}else{
return FALSE;
}
}
Produit Produit::lire_clavier() {
int code;
string libelle; // Utilisation de string au lieu de char[]
double prixUnitaire;
cout << "Entrez le code du produit : ";
cin >> code;
cout << "Entrez le libellé du produit : ";
cin >> libelle;
cout << "Entrez le prix unitaire du produit : ";
cin >> prixUnitaire;
return Produit(code, libelle, prixUnitaire);
}
int Produit::montant(const Produit tab[], int taille) {
int totalPrix = 0;
for (int i = 0; i < taille; ++i) {
totalPrix += tab[i].prixUnitaire;
}
return totalPrix;
}
C)-------------
#include "produit.h"
#ifndef PROMOTION_H
#define PROMOTION_H
#include <string>
class Promotion : public Produit {
private:
double remise;
public:
Promotion(int codep, const std::string libellep, int prixUnitairep, double remise);
Promotion(const Promotion& p);
~Promotion();
void affichage() ;
double montant() ;
};
#endif // PROMOTION_H
D)------------
#include "produit.h"
#include "promotion.h"
#include <iostream>
#include <string>
using namespace std;
Promotion::Promotion(int codep, string libellep, int prixUnitairep, double remise) : Produit(codep, libellep, prixUnitairep) {
(*this).remise = remise; }
Promotion::Promotion(const Promotion& p) : Produit(p){
(*this).remise=p.remise;
}
Promotion::~Promotion() {}
void Promotion::affichage() {
cout << "Produit En Promotion (Code " << Produit::code << ", Libellé " << Produit::getLibelle() << ", Prix Unitaire " << Produit::getPrixUnitaire() << ", Remise " << (*this).remise << "%)." << endl;
}
double Promotion::montant() {
return Produit::getPrixUnitaire() - (Produit::getPrixUnitaire() -0,1);
}
