EVALUATION EN C++ TEST  07/ XX   

EXAMEN C++ , EXAMEN CORRIGE C++

GROUPE GENIUS
GROUPE GENIUS © 2024 PAR Mr Joël Yankam [contact +237 652027193] www.PandaCodeur.com

ÉNONCÉ DE LA SESSION NORMALE C++

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
Énoncé de la Session Normale C++

Énoncé de la Session Normale C++

Exercice 1 (7.5 pts)

Le but de cet exercice est de définir une classe Carré sachant qu'un carré est défini par son point supérieur gauche et la longueur de son côté.

Partie A: La Classe Point en dimension 2 (3 pts)

1) Définir une classe Point en dimension 2 dont les données membres sont l'abscisse, l'ordonnée, le nombre de points et dont les méthodes membres sont:

  • un constructeur
  • un destructeur
  • des accesseurs en modification et en consultation
  • la définition des opérateurs ++ (incrémentation de l'abscisse et de l'ordonnée de 1) et -- (décrémentation de l'abscisse et de l'ordonnée de 1)

2) Définir une fonction amie pour l'addition de deux points sachant que le résultat de (x, y) + (a, b) est (x + a, y + b).

Partie B: La Classe Carré en dimension 2 (4 pts)

3) Définir une classe Carré en dimension 2 dont les données membres sont le point supérieur gauche et la longueur d'un côté et dont les méthodes membres sont:

  • un constructeur
  • des accesseurs en modification et en consultation
  • le calcul du périmètre
  • le calcul de la surface
  • le calcul du point inférieur droit
  • la définition de l'opérateur + (p + n où p est un objet de la classe Point et n un nombre signifie qu'on doit ajouter n à la valeur du côté de p)

Problème (13 pts)

Le but de ce problème est de gérer les commandes de produits.

Partie A: La classe Produit (2 pts)

1) Définir une classe Produit ayant pour variables d'instance le code produit, le libellé et le prix unitaire. On suppose qu'on n'a pas le droit de changer le code d'un Produit. Prévoir un constructeur qui prend en entrée toutes les variables d'instance à l'exception du code produit. Écrire une méthode qui retourne le prix de vente d'un produit.

Partie B: La classe ProduitEnPromotion (2 pts)

2) Définir une classe ProduitEnPromotion comme classe fille de la classe Produit sachant que chaque produit en promotion a un taux de remise. Prévoir un constructeur qui prend en entrée toutes les variables d'instance à l'exception du code produit (libellé, prix unitaire, taux de remise). Écrire une méthode qui retourne le prix de vente d'un produit en promotion.

Partie C: La classe CommandeUnProduit (2 pts)

3) La classe CommandeUnProduit permet de modéliser une commande portant sur le même produit. Elle a deux variables d'instance, à savoir:

  • le produit commandé
  • la quantité commandée

Définir cette classe avec un constructeur qui prend en entrée un Produit et la quantité commandée. Écrire une méthode qui retourne le montant d'un objet de CommandeUnProduit.

Partie D: La classe Commande

Une Commande est définie par:

  • un tableau contenant des objets de CommandeUnProduit
  • la taille du tableau
  • la prochaine case libre du tableau

4) Définir une classe Commande, un constructeur qui prend en entrée la taille maximale du tableau et un destructeur. (1 pt)

5) Définir une méthode qui ajoute un objet de CommandeUnProduit à une commande. (1 pt)

6) Définir une méthode qui calcule et retourne le montant d'une commande. (1 pt)

7) Définir une méthode qui supprime un objet de CommandeUnProduit dans une commande. (1 pt)

8) Définir une méthode qui calcule et retourne le nombre de produits en promotion d'une commande. (1 pt)

9) Définir une méthode d'instance qui écrit toutes les commandes du tableau dans un fichier. (1 pt)

10) Définir une méthode d'instance qui lit toutes les commandes d'un fichier et les ajoute dans un tableau. (1 pt)

Contact: Mr Joël Yankam | +237 652027193 | www.PandaCodeur.com

Correction :

Énoncé de la Session Normale C++
GROUPE GENIUS
GROUPE GENIUS © 2024 PAR Mr Joël Yankam [contact +237 652027193] www.PandaCodeur.com

ÉLÉMENT DE CORRECTION DE LA SESSION NORMALE C++

Proposé par : GROUPE GENIUS RÉPÉTITION

Par : Mr Joël Yk

INF 162 (2023-2024)

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;
}

        
Contact: Mr Joël Yankam | +237 652027193 | www.PandaCodeur.com

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;
    }
}
        

Télécharger L'exercice Sous Forme de PDF

 
Aucune note. Soyez le premier à attribuer une note !

Ajouter un commentaire

Anti-spam