Voici une version mise à jour du **Diagramme de Classes** avec une description détaillée de chaque
méthode pour clarifier son rôle et sa fonctionnalité.
---
### **Diagramme de Classes avec Descriptions des Méthodes**
#### **Classes :**
1. **Personne** (Classe abstraite)
- Attributs :
- `nom : string`
- `age : int`
- Méthodes :
- `virtual void afficherInfos() = 0`
**Description** : Affiche les informations de la personne (nom et âge). Cette méthode doit être
implémentée par les classes dérivées.
2. **Employé** (Hérite de **Personne**)
- Attributs :
- `idEmploye : int`
- `poste : string`
- Méthodes :
- `void afficherInfos() override`
**Description** : Affiche les informations de l'employé (nom, âge, ID, et poste).
- `void travailler()`
**Description** : Simule l'action de travailler pour l'employé.
3. **Opérateur** (Hérite de **Employé**)
- Attributs :
- `specialisation : string`
- Méthodes :
- `void gererProduction()`
**Description** : Gère le processus de production en utilisant les machines disponibles.
4. **Gestionnaire** (Hérite de **Employé**)
- Attributs :
- `departement : string`
- Méthodes :
- `void genererRapports()`
**Description** : Génère des rapports sur l'état de la production, de l'inventaire, et de la qualité.
5. **Administrateur** (Hérite de **Employé**)
- Attributs :
- `niveauAcces : int`
- Méthodes :
- `void gererPersonnel()`
**Description** : Gère les informations et les activités du personnel (ajout, suppression, mise à
jour).
6. **Machine**
- Attributs :
- `idMachine : int`
- `etat : string` (partie dynamique)
- Méthodes :
- `void demarrer()`
**Description** : Démarre la machine et met son état à "en marche".
- `void arreter()`
**Description** : Arrête la machine et met son état à "arrêtée".
7. **MachineProduction** (Hérite de **Machine**)
- Attributs :
- `capacite : int`
- Méthodes :
- `void produire()`
**Description** : Utilise la machine pour produire des articles en fonction de sa capacité.
8. **MachineControleQualite** (Hérite de **Machine**)
- Attributs :
- `precision : double`
- Méthodes :
- `void verifierQualite()`
**Description** : Vérifie la qualité des produits fabriqués en utilisant la précision de la machine.
9. **Commande**
- Attributs :
- `idCommande : int`
- `date : string`
- `produitsCommandes : vector<string>` (attribut vector)
- Méthodes :
- `void ajouterProduit(string produit)`
**Description** : Ajoute un produit à la liste des produits commandés.
- `void afficherDetails()`
**Description** : Affiche les détails de la commande (ID, date, et liste des produits).
10. **Inventaire**
- Attributs :
- `stock : map<string, int>`
- Méthodes :
- `void mettreAJourStock(string produit, int quantite)`
**Description** : Met à jour la quantité d'un produit dans l'inventaire.
- `int verifierStock(string produit)`
**Description** : Retourne la quantité disponible d'un produit dans l'inventaire.
11. **Rapport**
- Attributs :
- `idRapport : int`
- `contenu : string` (partie dynamique)
- Méthodes :
- `void generer()`
**Description** : Génère un rapport en fonction des données disponibles (production,
inventaire, qualité).
12. **Qualite** (Héritage multiple de **MachineControleQualite** et **Rapport**)
- Attributs :
- `niveauQualite : string`
- Méthodes :
- `void evaluer()`
**Description** : Évalue la qualité des produits et génère un rapport de contrôle qualité.
---
### **Résumé des Fonctionnalités :**
- **Personne** : Classe abstraite qui définit une structure de base pour les informations
personnelles.
- **Employé** : Classe concrète qui représente un employé avec des méthodes pour afficher ses
informations et travailler.
- **Opérateur** : Gère la production en utilisant des machines.
- **Gestionnaire** : Génère des rapports sur l'état de l'entreprise.
- **Administrateur** : Gère les informations du personnel.
- **Machine** : Classe de base pour les machines avec des méthodes pour les démarrer et les
arrêter.
- **MachineProduction** : Utilisée pour produire des articles.
- **MachineControleQualite** : Utilisée pour vérifier la qualité des produits.
- **Commande** : Représente une commande avec une liste de produits.
- **Inventaire** : Gère le stock des produits.
- **Rapport** : Génère des rapports sur l'état de l'entreprise.
- **Qualite** : Combine les fonctionnalités de contrôle qualité et de génération de rapports.
---
Ce diagramme de classes est maintenant complet avec des descriptions détaillées pour chaque
méthode, ce qui facilite la compréhension de leur rôle et de leur fonctionnement.
Vous avez raison, les méthodes comme `gererPersonnel` ou `genererRapports` peuvent sembler trop
abstraites sans détails concrets. Je vais vous fournir des **méthodes concrètes avec des descriptions
précises** pour chaque classe, en expliquant ce qu'elles font de manière détaillée.
---
### **Diagramme de Classes avec Méthodes Concrètes**
#### **1. Classe : Opérateur**
- **Méthodes :**
- `void demarrerMachine(idMachine: int)`
**Description** : Démarre une machine spécifique en utilisant son ID. Vérifie si la machine est
déjà en marche avant de lancer le processus.
- `void arreterMachine(idMachine: int)`
**Description** : Arrête une machine spécifique en utilisant son ID. Vérifie si la machine est déjà
arrêtée.
- `void verifierDefauts(produit: string)`
**Description** : Vérifie si un produit spécifique présente des défauts et enregistre les résultats
dans un journal.
---
#### **2. Classe : Gestionnaire**
- **Méthodes :**
- `void planifierProduction(produit: string, quantite: int)`
**Description** : Planifie la production d'un produit en spécifiant la quantité à produire. Met à
jour l'inventaire et les ressources nécessaires.
- `void commanderMatierePremiere(matiere: string, quantite: int)`
**Description** : Passe une commande pour des matières premières spécifiques en fonction des
besoins de production.
- `void genererRapportMensuel()`
**Description** : Génère un rapport mensuel détaillant la production, les ventes, et les niveaux de
stock.
---
#### **3. Classe : Administrateur**
- **Méthodes :**
- `void ajouterEmploye(nom: string, poste: string)`
**Description** : Ajoute un nouvel employé à la base de données avec son nom et son poste.
- `void supprimerEmploye(idEmploye: int)`
**Description** : Supprime un employé de la base de données en utilisant son ID.
- `void modifierPosteEmploye(idEmploye: int, nouveauPoste: string)`
**Description** : Modifie le poste d'un employé existant en utilisant son ID.
---
#### **4. Classe : Machine**
- **Méthodes :**
- `void demarrer()`
**Description** : Démarre la machine et met son état à "en marche".
- `void arreter()`
**Description** : Arrête la machine et met son état à "arrêtée".
- `void diagnostiquerProbleme()`
**Description** : Effectue un diagnostic pour détecter les problèmes techniques de la machine.
---
#### **5. Classe : MachineProduction**
- **Méthodes :**
- `void produireArticle(article: string, quantite: int)`
**Description** : Produit une quantité spécifiée d'un article en utilisant la machine.
- `void ajusterCapacite(nouvelleCapacite: int)`
**Description** : Ajuste la capacité de production de la machine.
---
#### **6. Classe : MachineControleQualite**
- **Méthodes :**
- `void verifierQualite(produit: string)`
**Description** : Vérifie la qualité d'un produit spécifique et enregistre les résultats.
- `void calibrerMachine()`
**Description** : Calibre la machine pour garantir une précision optimale.
---
#### **7. Classe : Commande**
- **Méthodes :**
- `void ajouterProduit(produit: string)`
**Description** : Ajoute un produit à la liste des produits commandés.
- `void afficherDetails()`
**Description** : Affiche les détails de la commande (ID, date, et liste des produits).
- `void calculerCoutTotal()`
**Description** : Calcule le coût total de la commande en fonction des produits ajoutés.
---
#### **8. Classe : Inventaire**
- **Méthodes :**
- `void ajouterStock(produit: string, quantite: int)`
**Description** : Ajoute une quantité spécifiée d'un produit à l'inventaire.
- `void retirerStock(produit: string, quantite: int)`
**Description** : Retire une quantité spécifiée d'un produit de l'inventaire.
- `int verifierStock(produit: string)`
**Description** : Retourne la quantité disponible d'un produit dans l'inventaire.
---
#### **9. Classe : Rapport**
- **Méthodes :**
- `void genererRapportProduction()`
**Description** : Génère un rapport détaillant la production mensuelle.
- `void genererRapportQualite()`
**Description** : Génère un rapport sur la qualité des produits fabriqués.
- `void exporterRapport(format: string)`
**Description** : Exporte le rapport dans un format spécifié (PDF, Excel, etc.).
---
#### **10. Classe : Qualite**
- **Méthodes :**
- `void evaluerProduit(produit: string)`
**Description** : Évalue la qualité d'un produit spécifique et génère un rapport.
- `void notifierDefaut(produit: string, defaut: string)`
**Description** : Notifie les équipes concernées en cas de défaut détecté sur un produit.
---
### **Exemple de Diagramme de Classes avec Méthodes Concrètes :**
```
----------------------------------
| Opérateur |
----------------------------------
| - specialisation: string |
----------------------------------
| + demarrerMachine(idMachine: int): void |
| + arreterMachine(idMachine: int): void |
| + verifierDefauts(produit: string): void|
----------------------------------
```
```
----------------------------------
| Gestionnaire |
----------------------------------
| - departement: string |
----------------------------------
| + planifierProduction(produit: string, quantite: int): void |
| + commanderMatierePremiere(matiere: string, quantite: int): void |
| + genererRapportMensuel(): void|
----------------------------------
```
---
### **Conclusion :**
Ces méthodes concrètes décrivent des actions spécifiques que chaque classe peut effectuer. Vous
pouvez maintenant les intégrer dans votre diagramme de classes UML pour le rendre plus détaillé et
prêt pour l'implémentation. Si vous utilisez un outil comme **Lucidchart** ou **Draw.io**, vous
pouvez ajouter ces méthodes directement dans les classes correspondantes.
La classe **MachineProduction** est une classe spécialisée qui hérite de la classe **Machine**. Elle
représente une machine utilisée spécifiquement pour la production dans un environnement
industriel. Voici une explication détaillée de cette classe, incluant ses **attributs**, ses
**méthodes**, et son **rôle** dans le système.
---
### **Classe : MachineProduction**
#### **Héritage :**
- **MachineProduction** hérite de **Machine**. Cela signifie qu'elle hérite des attributs et
méthodes de la classe **Machine** (comme `idMachine`, `etat`, `demarrer()`, et `arreter()`), tout en
ajoutant ses propres spécificités liées à la production.
---
#### **Attributs :**
1. **`capacite : int`**
- **Description** : La capacité maximale de production de la machine (par exemple, le nombre
d'unités qu'elle peut produire par heure ou par jour).
- **Exemple** : Si `capacite = 100`, la machine peut produire 100 unités par heure.
---
#### **Méthodes :**
1. **`void produireArticle(article: string, quantite: int)`**
- **Description** : Cette méthode permet à la machine de produire une quantité spécifiée d'un
article donné.
- **Fonctionnement** :
- Vérifie si la quantité demandée est inférieure ou égale à la capacité de la machine.
- Si oui, lance la production et met à jour l'état de la machine.
- Si non, retourne une erreur ou une notification indiquant que la capacité est insuffisante.
- **Exemple** : `produireArticle("chaise", 50)` produit 50 chaises.
2. **`void ajusterCapacite(nouvelleCapacite: int)`**
- **Description** : Cette méthode permet de modifier la capacité de production de la machine.
- **Fonctionnement** :
- Met à jour l'attribut `capacite` avec la nouvelle valeur fournie.
- Vérifie si la nouvelle capacité est valide (par exemple, positive).
- **Exemple** : `ajusterCapacite(150)` change la capacité de la machine à 150 unités par heure.
3. **`void verifierEtatProduction()`**
- **Description** : Cette méthode vérifie l'état actuel de la production (par exemple, si la machine
est en marche, en pause, ou arrêtée).
- **Fonctionnement** :
- Utilise l'attribut `etat` hérité de la classe **Machine**.
- Retourne un message indiquant l'état de la production.
- **Exemple** : Si `etat = "en marche"`, la méthode retourne "La machine est en cours de
production."
---
#### **Rôle dans le système :**
- La classe **MachineProduction** est utilisée pour modéliser les machines dédiées à la fabrication
ou à l'assemblage de produits.
- Elle permet de :
1. **Produire des articles** en respectant les contraintes de capacité.
2. **Adapter la capacité** de production en fonction des besoins.
3. **Suivre l'état** de la machine pour garantir une production efficace.
---
### **Exemple de Code en C++ :**
```cpp
#include <iostream>
#include <string>
using namespace std;
class Machine {
protected:
int idMachine;
string etat;
public:
Machine(int id, string etatInitial) : idMachine(id), etat(etatInitial) {}
void demarrer() {
etat = "en marche";
cout << "Machine " << idMachine << " démarrée." << endl;
void arreter() {
etat = "arrêtée";
cout << "Machine " << idMachine << " arrêtée." << endl;
string getEtat() const {
return etat;
};
class MachineProduction : public Machine {
private:
int capacite;
public:
MachineProduction(int id, string etatInitial, int cap) : Machine(id, etatInitial), capacite(cap) {}
void produireArticle(string article, int quantite) {
if (quantite <= capacite) {
cout << "Production de " << quantite << " " << article << " en cours..." << endl;
} else {
cout << "Erreur : Capacité insuffisante pour produire " << quantite << " " << article << "." <<
endl;
void ajusterCapacite(int nouvelleCapacite) {
if (nouvelleCapacite > 0) {
capacite = nouvelleCapacite;
cout << "Capacité ajustée à " << capacite << " unités/heure." << endl;
} else {
cout << "Erreur : Capacité invalide." << endl;
void verifierEtatProduction() {
cout << "État de la machine " << idMachine << " : " << getEtat() << endl;
};
int main() {
MachineProduction machine1(101, "arrêtée", 100);
machine1.demarrer();
machine1.produireArticle("chaise", 50);
machine1.ajusterCapacite(150);
machine1.verifierEtatProduction();
machine1.arreter();
return 0;
```
---
### **Explication du Code :**
1. **Machine** : Classe de base avec des méthodes pour démarrer et arrêter la machine.
2. **MachineProduction** : Classe dérivée qui ajoute des fonctionnalités spécifiques à la production.
3. **Exemple d'utilisation** :
- La machine est démarrée.
- Elle produit 50 chaises.
- Sa capacité est ajustée à 150 unités/heure.
- Son état est vérifié.
- Elle est finalement arrêtée.
---
### **Représentation UML :**
```
----------------------------------
| MachineProduction |
----------------------------------
| - capacite: int |
----------------------------------
| + produireArticle(article: string, quantite: int): void |
| + ajusterCapacite(nouvelleCapacite: int): void |
| + verifierEtatProduction(): void |
----------------------------------
```
---
### **Conclusion :**
La classe **MachineProduction** est essentielle pour modéliser les machines de production dans un
système industriel. Elle combine les fonctionnalités de base d'une machine avec des méthodes
spécifiques pour gérer la production, ajuster la capacité, et surveiller l'état de la machine. Cela en fait
un composant clé pour la gestion efficace des processus de fabrication.
Classepiece :
Voici une proposition pour les trois classes **PieceVoitureElectrique**, **PieceVoitureMecanique**,
et **PieceVoitureHybride**, avec des **attributs** et des **méthodes spécifiques**. La classe
**PieceVoitureHybride** hérite des deux autres classes, ce qui permet de combiner les
fonctionnalités des pièces électriques et mécaniques.
---
### **1. Classe : PieceVoitureElectrique**
#### **Attributs :**
- `tensionNominale : double` : La tension nominale de la pièce (en volts).
- `autonomie : double` : L'autonomie de la pièce (en heures ou en kilomètres).
- `estBranche : bool` : Indique si la pièce est branchée ou non.
#### **Méthodes :**
1. **`void brancher()`**
- **Description** : Branche la pièce électrique à une source d'alimentation.
- **Fonctionnement** : Met à jour l'attribut `estBranche` à `true`.
- **Exemple** : `brancher()` permet de démarrer la pièce électrique.
2. **`void debrancher()`**
- **Description** : Débranche la pièce électrique.
- **Fonctionnement** : Met à jour l'attribut `estBranche` à `false`.
- **Exemple** : `debrancher()` arrête la pièce électrique.
3. **`void verifierAutonomie()`**
- **Description** : Vérifie l'autonomie restante de la pièce.
- **Fonctionnement** : Affiche un message indiquant l'autonomie restante.
- **Exemple** : `verifierAutonomie()` affiche "Autonomie restante : 5 heures."
---
### **2. Classe : PieceVoitureMecanique**
#### **Attributs :**
- `usure : double` : Le niveau d'usure de la pièce (en pourcentage).
- `vitesseMax : double` : La vitesse maximale supportée par la pièce (en km/h).
- `estLubrifiee : bool` : Indique si la pièce est lubrifiée ou non.
#### **Méthodes :**
1. **`void lubrifier()`**
- **Description** : Lubrifie la pièce mécanique pour réduire l'usure.
- **Fonctionnement** : Met à jour l'attribut `estLubrifiee` à `true`.
- **Exemple** : `lubrifier()` réduit l'usure de la pièce.
2. **`void verifierUsure()`**
- **Description** : Vérifie le niveau d'usure de la pièce.
- **Fonctionnement** : Affiche un message indiquant le niveau d'usure.
- **Exemple** : `verifierUsure()` affiche "Usure actuelle : 15%."
3. **`void ajusterVitesseMax(nouvelleVitesse: double)`**
- **Description** : Ajuste la vitesse maximale supportée par la pièce.
- **Fonctionnement** : Met à jour l'attribut `vitesseMax` avec la nouvelle valeur.
- **Exemple** : `ajusterVitesseMax(200)` change la vitesse maximale à 200 km/h.
---
### **3. Classe : PieceVoitureHybride**
#### **Héritage :**
- **PieceVoitureHybride** hérite à la fois de **PieceVoitureElectrique** et de
**PieceVoitureMecanique**. Cela permet de combiner les fonctionnalités des deux types de pièces.
#### **Attributs :**
- `modeActuel : string` : Le mode actuel de fonctionnement (électrique, mécanique, ou hybride).
- `efficaciteHybride : double` : L'efficacité de la pièce en mode hybride (en pourcentage).
#### **Méthodes :**
1. **`void changerMode(nouveauMode: string)`**
- **Description** : Change le mode de fonctionnement de la pièce (électrique, mécanique, ou
hybride).
- **Fonctionnement** : Met à jour l'attribut `modeActuel` avec le nouveau mode.
- **Exemple** : `changerMode("hybride")` active le mode hybride.
2. **`void calculerEfficacite()`**
- **Description** : Calcule l'efficacité globale de la pièce en mode hybride.
- **Fonctionnement** : Combine les données électriques et mécaniques pour calculer l'efficacité.
- **Exemple** : `calculerEfficacite()` affiche "Efficacité hybride : 85%."
3. **`void verifierCompatibilite()`**
- **Description** : Vérifie si les composants électriques et mécaniques sont compatibles pour
fonctionner ensemble.
- **Fonctionnement** : Compare les attributs des deux classes parentes et affiche un message de
compatibilité.
- **Exemple** : `verifierCompatibilite()` affiche "Compatibilité vérifiée : OK."
---
### **Représentation UML :**
```
----------------------------------
| PieceVoitureElectrique |
----------------------------------
| - tensionNominale: double |
| - autonomie: double |
| - estBranche: bool |
----------------------------------
| + brancher(): void |
| + debrancher(): void |
| + verifierAutonomie(): void |
----------------------------------
```
```
----------------------------------
| PieceVoitureMecanique |
----------------------------------
| - usure: double |
| - vitesseMax: double |
| - estLubrifiee: bool |
----------------------------------
| + lubrifier(): void |
| + verifierUsure(): void |
| + ajusterVitesseMax(vitesse: double): void |
----------------------------------
```
```
----------------------------------
| PieceVoitureHybride |
----------------------------------
| - modeActuel: string |
| - efficaciteHybride: double |
----------------------------------
| + changerMode(mode: string): void |
| + calculerEfficacite(): void |
| + verifierCompatibilite(): void|
----------------------------------
```
---
### **Exemple de Code en C++ :**
```cpp
#include <iostream>
#include <string>
using namespace std;
class PieceVoitureElectrique {
protected:
double tensionNominale;
double autonomie;
bool estBranche;
public:
PieceVoitureElectrique(double tension, double autoNominale)
: tensionNominale(tension), autonomie(autoNominale), estBranche(false) {}
void brancher() {
estBranche = true;
cout << "Pièce électrique branchée." << endl;
void debrancher() {
estBranche = false;
cout << "Pièce électrique débranchée." << endl;
void verifierAutonomie() {
cout << "Autonomie restante : " << autonomie << " heures." << endl;
};
class PieceVoitureMecanique {
protected:
double usure;
double vitesseMax;
bool estLubrifiee;
public:
PieceVoitureMecanique(double usureInit, double vitesse)
: usure(usureInit), vitesseMax(vitesse), estLubrifiee(false) {}
void lubrifier() {
estLubrifiee = true;
cout << "Pièce mécanique lubrifiée." << endl;
void verifierUsure() {
cout << "Usure actuelle : " << usure << "%." << endl;
void ajusterVitesseMax(double nouvelleVitesse) {
vitesseMax = nouvelleVitesse;
cout << "Vitesse maximale ajustée à " << vitesseMax << " km/h." << endl;
};
class PieceVoitureHybride : public PieceVoitureElectrique, public PieceVoitureMecanique {
private:
string modeActuel;
double efficaciteHybride;
public:
PieceVoitureHybride(double tension, double autoNominale, double usureInit, double vitesse)
: PieceVoitureElectrique(tension, autoNominale), PieceVoitureMecanique(usureInit, vitesse),
modeActuel("électrique"), efficaciteHybride(0) {}
void changerMode(string nouveauMode) {
modeActuel = nouveauMode;
cout << "Mode changé à : " << modeActuel << "." << endl;
}
void calculerEfficacite() {
efficaciteHybride = (tensionNominale * 0.5) + (vitesseMax * 0.3);
cout << "Efficacité hybride : " << efficaciteHybride << "%." << endl;
void verifierCompatibilite() {
if (tensionNominale >= 200 && vitesseMax >= 150) {
cout << "Compatibilité vérifiée : OK." << endl;
} else {
cout << "Compatibilité vérifiée : Problème détecté." << endl;
};
int main() {
PieceVoitureHybride pieceHybride(220, 10, 15, 180);
pieceHybride.brancher();
pieceHybride.lubrifier();
pieceHybride.changerMode("hybride");
pieceHybride.calculerEfficacite();
pieceHybride.verifierCompatibilite();
return 0;
```
---
### **Explication du Code :**
1. **PieceVoitureElectrique** : Gère les fonctionnalités électriques (brancher, débrancher, vérifier
l'autonomie).
2. **PieceVoitureMecanique** : Gère les fonctionnalités mécaniques (lubrifier, vérifier l'usure,
ajuster la vitesse).
3. **PieceVoitureHybride** : Combine les deux et ajoute des méthodes spécifiques pour gérer le
mode hybride, calculer l'efficacité, et vérifier la compatibilité.
---
### **Conclusion :**
Ces trois classes modélisent des pièces de voiture électriques, mécaniques et hybrides. La classe
**PieceVoitureHybride** hérite des deux autres et ajoute des fonctionnalités spécifiques pour gérer
les modes de fonctionnement et l'efficacité. Cela permet une modélisation flexible et réaliste des
systèmes hybrides dans un contexte industriel.
Les attributs dynamiques :
Dans les **classes de début** que nous avons définies précédemment, les **attributs dynamiques**
sont ceux dont la valeur peut changer pendant l'exécution du programme. Ces attributs représentent
des états ou des propriétés qui évoluent en fonction des actions effectuées sur les objets.
Voici une analyse des **attributs dynamiques** pour chaque classe :
---
### **1. Classe : Machine**
- **Attributs dynamiques :**
- **`etat : string`**
- **Description** : L'état de la machine (par exemple, "en marche", "arrêtée", "en pause").
- **Pourquoi dynamique ?** : Cet attribut change lorsque la machine est démarrée ou arrêtée.
---
### **2. Classe : MachineProduction**
- **Attributs dynamiques :**
- **`capacite : int`**
- **Description** : La capacité de production de la machine.
- **Pourquoi dynamique ?** : Cet attribut peut être modifié via la méthode `ajusterCapacite`.
---
### **3. Classe : MachineControleQualite**
- **Attributs dynamiques :**
- **`precision : double`**
- **Description** : La précision de la machine pour vérifier la qualité.
- **Pourquoi dynamique ?** : Cet attribut peut être recalibré ou ajusté pendant l'exécution.
---
### **4. Classe : Commande**
- **Attributs dynamiques :**
- **`produitsCommandes : vector<string>`**
- **Description** : La liste des produits commandés.
- **Pourquoi dynamique ?** : Cet attribut change lorsque des produits sont ajoutés ou retirés de
la commande.
---
### **5. Classe : Inventaire**
- **Attributs dynamiques :**
- **`stock : map<string, int>`**
- **Description** : Le stock des produits disponibles.
- **Pourquoi dynamique ?** : Cet attribut est mis à jour lorsque des produits sont ajoutés ou
retirés de l'inventaire.
---
### **6. Classe : Rapport**
- **Attributs dynamiques :**
- **`contenu : string`**
- **Description** : Le contenu du rapport.
- **Pourquoi dynamique ?** : Cet attribut est modifié lorsque le rapport est généré ou mis à jour.
---
### **7. Classe : PieceVoitureElectrique**
- **Attributs dynamiques :**
- **`estBranche : bool`**
- **Description** : Indique si la pièce est branchée ou non.
- **Pourquoi dynamique ?** : Cet attribut change lorsque la pièce est branchée ou débranchée.
---
### **8. Classe : PieceVoitureMecanique**
- **Attributs dynamiques :**
- **`usure : double`**
- **Description** : Le niveau d'usure de la pièce.
- **Pourquoi dynamique ?** : Cet attribut évolue avec l'utilisation de la pièce.
- **`estLubrifiee : bool`**
- **Description** : Indique si la pièce est lubrifiée ou non.
- **Pourquoi dynamique ?** : Cet attribut change lorsque la pièce est lubrifiée.
---
### **9. Classe : PieceVoitureHybride**
- **Attributs dynamiques :**
- **`modeActuel : string`**
- **Description** : Le mode de fonctionnement actuel (électrique, mécanique, hybride).
- **Pourquoi dynamique ?** : Cet attribut change lorsque le mode est modifié.
- **`efficaciteHybride : double`**
- **Description** : L'efficacité de la pièce en mode hybride.
- **Pourquoi dynamique ?** : Cet attribut est recalculé en fonction des performances électriques
et mécaniques.
---
### **Résumé des Attributs Dynamiques :**
| Classe | Attributs Dynamiques |
|-------------------------|------------------------------------------|
| **Machine** | `etat : string` |
| **MachineProduction** | `capacite : int` |
| **MachineControleQualite** | `precision : double` |
| **Commande** | `produitsCommandes : vector<string>` |
| **Inventaire** | `stock : map<string, int>` |
| **Rapport** | `contenu : string` |
| **PieceVoitureElectrique** | `estBranche : bool` |
| **PieceVoitureMecanique** | `usure : double`, `estLubrifiee : bool` |
| **PieceVoitureHybride** | `modeActuel : string`, `efficaciteHybride : double` |
---
### **Exemple d'Utilisation des Attributs Dynamiques :**
#### **Classe : Machine**
```cpp
Machine machine(101, "arrêtée");
machine.demarrer(); // etat devient "en marche"
machine.arreter(); // etat devient "arrêtée"
```
#### **Classe : Commande**
```cpp
Commande commande(1, "2023-10-01");
commande.ajouterProduit("chaise"); // produitsCommandes contient maintenant "chaise"
commande.ajouterProduit("table"); // produitsCommandes contient maintenant "chaise" et "table"
```
#### **Classe : PieceVoitureHybride**
```cpp
PieceVoitureHybride pieceHybride(220, 10, 15, 180);
pieceHybride.changerMode("hybride"); // modeActuel devient "hybride"
pieceHybride.calculerEfficacite(); // efficaciteHybride est recalculée
```
---
### **Conclusion :**
Les **attributs dynamiques** sont essentiels pour modéliser des états ou des propriétés qui
évoluent pendant l'exécution du programme. Ils permettent de refléter les changements dans le
comportement des objets et sont souvent modifiés via des méthodes spécifiques. Dans les classes
que nous avons définies, ces attributs jouent un rôle clé pour gérer les états des machines, des
commandes, des pièces de voiture, etc.
