Partie A: La Classe Point en dimension 2

1. Définir une classe Point en dimension 2

• int x : l'abscisse du point
• int y : l'ordonnée du point
• static int nombre_points : le nombre de points créés

Les méthodes membres seront :

1. Un constructeur
2. Un destructeur
3. Des accesseurs en modification et en consultation
4. Les opérateurs ++ (incrémentation) et -- (décrémentation)
5. Une fonction amie pour l'addition de deux points

Partie B: La Classe Carré en dimension 2

2. Définir une classe Carré en dimension 2

• Point coin_superieur_gauche : le point supérieur gauche du carré
• int cote : la longueur du côté du carré

Les méthodes membres seront :

1. Un constructeur
2. Des accesseurs en modification et en consultation
3. Le calcul du périmètre
4. Le calcul de la surface
5. Le calcul du point inférieur gauche
6. L'opérateur += (ajout d'un nombre à la valeur du côté)

Partie C: La Classe Produit

1. Définir la classe Produit

• const int codeProduit : le code du produit (const)
• string nomProduit : le nom du produit
• int quantite : la quantité de produit en stock
• int prixUnitaire : le prix unitaire du produit

Les méthodes membres seront :

1. Un constructeur
2. Un destructeur
3. Les accesseurs en modification et en consultation
4. Les opérateurs == et != pour comparer deux produits

Partie A: La Classe Point en dimension 2

1. Définir une classe Point en dimension 2

• int x : l'abscisse du point
• int y : l'ordonnée du point
• static int nombre_points : le nombre de points créés

Les méthodes membres seront :

1. Un constructeur
2. Un destructeur
3. Des accesseurs en modification et en consultation
4. Les opérateurs ++ (incrémentation) et -- (décrémentation)
5. Une fonction amie pour l'addition de deux points

Code de la classe Point

Fichier d'en-tête point.h

#ifndef POINT_H
#define POINT_H

class Point {
private:
    int x; // Abscisse
    int y; // Ordonnée
    static int nombre_points; // Nombre de points créés

public:
    // Constructeur
    Point(int x = 0, int y = 0);

    // Destructeur
    ~Point();

    // Accesseurs en consultation
    int getX() const;
    int getY() const;

    // Accesseurs en modification
    void setX(int x);
    void setY(int y);

    // Opérateurs d'incrémentation et de décrémentation
    void operator++(); // Pré-incrémentation
    void operator--(); // Pré-décrémentation

    // Fonction amie pour l'addition de deux points
    friend Point operator+(const Point &p1, const Point &p2);
};

#endif // POINT_H

        

Fichier d'implémentation point.cpp

#include "point.h"

int Point::nombre_points = 0;

// Constructeur
Point::Point(int x, int y) : x(x), y(y) {
    nombre_points++;
}

// Destructeur
Point::~Point() {
    nombre_points--;
}

// Accesseurs en consultation
int Point::getX() const {
    return x;
}

int Point::getY() const {
    return y;
}

// Accesseurs en modification
void Point::setX(int x) {
    this->x = x;
}

void Point::setY(int y) {
    this->y = y;
}

// Opérateurs d'incrémentation et de décrémentation
void Point::operator++() {
    x++;
    y++;
}

void Point::operator--() {
    x--;
    y--;
}

// Fonction amie pour l'addition de deux points
Point operator+(const Point &p1, const Point &p2) {
    return Point(p1.x + p2.x, p1.y + p2.y);
}

        

Partie B: La Classe Carre en dimension 2

2. Définir une classe Carre en dimension 2

• Point coin_superieur_gauche : le point supérieur gauche du carré
• int cote : la longueur du côté du carré

1. Un constructeur
2. Des accesseurs en modification et en consultation
3. Le calcul du périmètre
4. Le calcul de la surface
5. Le calcul du point inférieur gauche
6. L'opérateur += (ajout d'un nombre à la valeur du côté)

Code de la classe Carre

Fichier d'en-tête carre.h

#ifndef CARRE_H
#define CARRE_H

#include "point.h"

class Carre {
private:
    Point coin_superieur_gauche; // Point supérieur gauche du carré
    int cote; // Longueur du côté du carré

public:
    // Constructeur
    Carre(Point psg = Point(), int cote = 1);

    // Accesseurs en consultation
    Point getCoinSuperieurGauche() const;
    int getCote() const;

    // Accesseurs en modification
    void setCoinSuperieurGauche(const Point &psg);
    void setCote(int cote);

    // Calcul du périmètre
    int perimetre() const;

    // Calcul de la surface
    int surface() const;

    // Calcul du point inférieur gauche
    Point getCoinInferieurGauche() const;

    // Opérateur += pour ajouter une valeur au côté
    void operator+=(int nb);
};

#endif // CARRE_H

        

Fichier d'implémentation carre.cpp

#include "carre.h"

// Constructeur
Carre::Carre(Point psg, int cote) : coin_superieur_gauche(psg), cote(cote) {}

// Accesseurs en consultation
Point Carre::getCoinSuperieurGauche() const {
    return coin_superieur_gauche;
}

int Carre::getCote() const {
    return cote;
}

// Accesseurs en modification
void Carre::setCoinSuperieurGauche(const Point &psg) {
    coin_superieur_gauche = psg;
}

void Carre::setCote(int cote) {
    this->cote = cote;
}

// Calcul du périmètre
int Carre::perimetre() const {
    return 4 * cote;
}

// Calcul de la surface
int Carre::surface() const {
    return cote * cote;
}

// Calcul du point inférieur gauche
Point Carre::getCoinInferieurGauche() const {
    return Point(coin_superieur_gauche.getX(), coin_superieur_gauche.getY() - cote);
}

// Opérateur += pour ajouter une valeur au côté
void Carre::operator+=(int nb) {
    cote += nb;
}

        

Problème : La Classe Produit

1. Définir la classe Produit

Les données membres seront :

• const int codeProduit : le code du produit (const)
• std::string libelle : le libellé du produit
• double prixUnitaire : le prix unitaire du produit

Les méthodes membres seront :

• Un constructeur
• Des accesseurs en consultation pour le code produit, le libellé et le prix unitaire

Code de la classe Produit

Fichier d'en-tête Produit.h

#ifndef PRODUIT_H
#define PRODUIT_H

#include <string>

class Produit {
private:
    const int codeProduit;
    std::string libelle;
    double prixUnitaire;

public:
    Produit(int code, const std::string &lib, double prix);

    double getPrix() const;
    int getCodeProduit() const;
    std::string getLibelle() const;
};

#endif // PRODUIT_H
        

Fichier d'implémentation Produit.cpp

#include "Produit.h"

Produit::Produit(int code, const std::string &lib, double prix) : codeProduit(code), libelle(lib), prixUnitaire(prix) {}

double Produit::getPrix() const {
    return prixUnitaire;
}

int Produit::getCodeProduit() const {
    return codeProduit;
}

std::string Produit::getLibelle() const {
    return libelle;
}
        

Partie B: La Classe ProduitEnPromotion

1. Définir la classe ProduitEnPromotion

Les données membres seront :

• double tauxRemise : le taux de remise en pourcentage

Les méthodes membres seront :

• Un constructeur
• Un accesseur pour le taux de remise
• Une méthode pour obtenir le prix après remise

Code de la classe ProduitEnPromotion

Fichier d'en-tête ProduitEnPromotion.h

#ifndef PRODUITENPROMOTION_H
#define PRODUITENPROMOTION_H

#include "Produit.h"

class ProduitEnPromotion : public Produit {
private:
    double tauxRemise;

public:
    ProduitEnPromotion(int code, const std::string &lib, double prix, double remise);

    double getPrix() const;
    double getTauxRemise() const;
};

#endif // PRODUITENPROMOTION_H
        

Fichier d'implémentation ProduitEnPromotion.cpp

#include "ProduitEnPromotion.h"

ProduitEnPromotion::ProduitEnPromotion(int code, const std::string &lib, double prix, double remise)
    : Produit(code, lib, prix), tauxRemise(remise) {}

double ProduitEnPromotion::getPrix() const {
    return Produit::getPrix() * (1 - tauxRemise / 100);
}

double ProduitEnPromotion::getTauxRemise() const {
    return tauxRemise;
}
        

Partie C: La Classe CommandeUnProduit

1. Définir la classe CommandeUnProduit

Les données membres seront :

• Produit* produit : un pointeur vers un produit
• int quantite : la quantité commandée

Les méthodes membres seront :

• Un constructeur
• Un accesseur pour le montant total de la commande
• Des accesseurs pour le produit et la quantité

Code de la classe CommandeUnProduit

Fichier d'en-tête CommandeUnProduit.h

#ifndef COMMANDEUNPRODUIT_H
#define COMMANDEUNPRODUIT_H

#include "Produit.h"

class CommandeUnProduit {
private:
    Produit* produit;
    int quantite;

public:
    CommandeUnProduit(Produit* prod, int qte);

    double getMontant() const;
    Produit* getProduit() const;
    int getQuantite() const;
};

#endif // COMMANDEUNPRODUIT_H
        

Fichier d'implémentation CommandeUnProduit.cpp

#include "CommandeUnProduit.h"

CommandeUnProduit::CommandeUnProduit(Produit* prod, int qte) : produit(prod), quantite(qte) {}

double CommandeUnProduit::getMontant() const {
    return produit->getPrix() * quantite;
}

Produit* CommandeUnProduit::getProduit() const {
    return produit;
}

int CommandeUnProduit::getQuantite() const {
    return quantite;
}
        

Partie D: La Classe Commande

1. Définir la classe Commande

Les données membres seront :

• CommandeUnProduit* tableau : un tableau de pointeurs vers des commandes de produits
• int tailleMax : la taille maximale du tableau
• int prochaineCaseLibre : l'indice de la prochaine case libre dans le tableau

Les méthodes membres seront :

• Un constructeur et un destructeur
• Une méthode pour ajouter une commande
• Une méthode pour obtenir le montant total des commandes
• Une méthode pour supprimer une commande
• Une méthode pour obtenir le nombre de produits en promotion
• Une méthode pour écrire les commandes dans un fichier
• Une méthode pour lire les commandes depuis un fichier

Code de la classe Commande

Fichier d'en-tête Commande.h

#ifndef COMMANDE_H
#define COMMANDE_H

#include "CommandeUnProduit.h"
#include "ProduitEnPromotion.h"
#include <fstream>

class Commande {
private:
    CommandeUnProduit* tableau;
    int tailleMax;
    int prochaineCaseLibre;

public:
    Commande(int taille);
    ~Commande();

    bool ajouterCommande(CommandeUnProduit* commande);
    double getMontantTotal() const;
    bool supprimerCommande(int index);
    int getNombreProduitsEnPromotion() const;
    void ecrireDansFichier(const std::string& nomFichier) const;
    void lireDepuisFichier(const std::string& nomFichier);
};

#endif // COMMANDE_H
        

Fichier d'implémentation Commande.cpp

#include "Commande.h"

Commande::Commande(int taille) : tailleMax(taille), prochaineCaseLibre(0) {
    tableau = new CommandeUnProduit*[tailleMax];
}

Commande::~Commande() {
    for (int i = 0; i < prochaineCaseLibre; i++) {
        delete tableau[i];
    }
    delete[] tableau;
}

bool Commande::ajouterCommande(CommandeUnProduit* commande) {
    if (prochaineCaseLibre < tailleMax) {
        tableau[prochaineCaseLibre++] = commande;
        return true;
    }
    return false;
}

double Commande::getMontantTotal() const {
    double montantTotal = 0.0;
    for (int i = 0; i < prochaineCaseLibre; i++) {
        montantTotal += tableau[i]->getMontant();
    }
    return montantTotal;
}

bool Commande::supprimerCommande(int index) {
    if (index < 0 || index >= prochaineCaseLibre) return false;
    delete tableau[index];
    for (int i = index; i < prochaineCaseLibre - 1; i++) {
        tableau[i] = tableau[i + 1];
    }
    prochaineCaseLibre--;
    return true;
}

int Commande::getNombreProduitsEnPromotion() const {
    int count = 0;
    for (int i = 0; i < prochaineCaseLibre; i++) {
        if (dynamic_cast(tableau[i]->getProduit()) != nullptr) {
            count++;
        }
    }
    return count;
}

void Commande::ecrireDansFichier(const std::string& nomFichier) const {
    std::ofstream fichier(nomFichier);
    if (fichier.is_open()) {
        for (int i = 0; i < prochaineCaseLibre; i++) {
            fichier << tableau[i]->getProduit()->getLibelle() << " "
                    << tableau[i]->getQuantite() << " "
                    << tableau[i]->getMontant() << std::endl;
        }
        fichier.close();
    } else {
        std::cout << "Impossible d'ouvrir le fichier!" << std::endl;
    }
}

void Commande::lireDepuisFichier(const std::string& nomFichier) {
    std::ifstream fichier(nomFichier);
    if (fichier.is_open()) {
        std::string libelle;
        int code, quantite;
        double prix;
        while (fichier >> code >> libelle >> prix >> quantite) {
            Produit* prod = new Produit(code, libelle, prix);
            ajouterCommande(new CommandeUnProduit(prod, quantite));
        }
        fichier.close();
    } else {
        std::cout << "Impossible d'ouvrir le fichier!" << std::endl;
    }
}