Compte rendu de tp

DJIAN Samuel
ASTRE Jonathan
L2-info
Compte rendu de tp
Partie A : Programmation en langage C
Traduction de l’énoncé en shéma entité/association
Vend
Clients
Employes
Magasin
Achète
Produits
Est composé
Rayons
Gère
Approvisionne
Fournisseurs
Du shéma Entité/Association au programme C
A partir du shéma ci-dessus nous avons choisi de créer une classe pour chaque entité (Produit,
Fournisseur, Rayon, Employé, Client), plus une classe Magasin qui a pour but de stocker toutes les
données sous forme de tableau de classes.
class Magasin
{
private:
Produit *TabProduits;
Rayon *TabRayons;
Employe *TabEmployes;
Fournisseur *TabFournisseurs;
Client *TabClients;
}
Pour les attributs des cinq autres classes, nous nous sommes servis :
1) des informations du texte
Rayon
: nom
Employé : nom, prénom, âge, salaire, adresse, rayon d’affectation, responsable
Produit
: quantité et seuil de réapprovisionnement
Client
: entreprise/particulier
2) des relations du schéma entité/association
Fournisseur : Produits
Produit
: Rayons, Clients,Fournisseurs
Rayon
: Produits, Employés
Employé : Rayons, Clients
Client
: Produits, Employés
3) du questionnaire
Produit
: prix d’achat, prix de vente
Fournisseur : ville, nombre de livraisons
Employé : nombre de ventes
Client
: dépense
Remplissage du système avec des données permettant de valider son comportement
Le remplissage du système se réalise lorsque l’on lance, dans le fichier main.cpp, le
constructeur par défaut de la classe magasin. Ce dernier lance successivement les constructeurs des
cinq autes classes. Pour nous permettre de répondre correctement aux questions nous avons décidé
de créer 4 rayons (obligatoire), 20 produits, 8 employés, 3 fournisseurs et 10 clients.
Pour simplifier le code et nous concentrer sur l'algorithmique, nous avons choisi d'attribuer 5
produits a chaque rayon, ainsi que 2 employés dont un responsable. 3 fournisseurs au total
fournissent le magasin et 10 clients (paticulier ou entreprise) achetant chacun 2 produits.
Algorithmes permettant de répondre aux questions
Les algorithmes permettant de répondre aux questions sont définis sous forme de méthodes de
la classe magasin. Ils sont codés dans le fichier fonction.cpp puis appelés dans le fichier main. Ces
méthodes sont définies en tant que void, elles ne renvoi donc rien, elles affichent seulement le
résultat. Pour des raisons évidantes d’accessibilité nous avons aussi du mettre en place des fonctions
get pour certains attributs.
Question a)
Algorithme: Magasin.NomVendeurs();
Données: Magasin M1;
Résultat:
//Pas de données de retour , juste de l'affichage
Début
entier i;
pour i de 1 à 8 faire
Afficher(M1.TableauEmployés[i].Nom());
Fin
Question b)
Algorithme: Magasin.NomVendeursTries();
Données: Magasin M1;
Résultat:
//Les vendeurs sont triés par nom dans le tableau de vendeur
Début
entier i,k ;
Employe eTemp ;
pour k de 1 à 7 faire
pour i de 1 à 7 faire
si Magasin.TableauEmployes[i] > Magasin.TableauEmployes[i+1] alors
eTemp  Magasin.TableauEmployes[i] ;
Magasin.TableauEmployes[i]  Magasin.TableauEmployes[i+1];
Magasin.TableauEmployes[i+1]  eTemp;
Fin
//Pour cette question nous n’avons pas directement utilisé cet algorithme, nous nous sommes servis
de la fonction « sort() » (tirée de algorithm.h) qui permet de trier une liste ou un tableau de chaine
de caractères, une fois l’opérateur « < » surchargé.
Cet opérateur surchargé ; comparer deux Employes grâce a « < » revient à comparer leur nom grâce
a la fonction « strcmp() » (tirée de string.h).
Question c)
Algorithme: Magasin.ProduitPlusCher();
Données: Magasin M1;
Résultat:
//Pas de données de retour , juste de l'affichage
Début
entiers i,PlusCher;
PlusCher  M1.TableauProduits[1].Prix();
pour i de 2 à 20 faire
si ( PlusCher < M1.TableauProduits[i].Prix()) alors
PlusCher  M1.TableauProduits[i].Prix();
Afficher(PlusCher);
Fin
Question d)
Algorithme: Magasin.ProduitQuantiteSeuil();
Données: Magasin M1;
Résultat:
//Pas de données de retour , juste de l'affichage
Début
entier i;
Afficher(« Nom du Produit Quantité Seuil »);
pour i de 1 à 20 faire
Afficher(TableauProduits[i].Nom());
Afficher(TableauProduits[i].Quantite());
Afficher(TableauProduits[i].Seuil());
Fin
Question g)
Algorithme: Magasin.ClientPlusDepense();
Données: Magasin M1;
Résultat:
//Pas de données de retour , juste de l'affichage
Début
entiers depense,i,client;
depense  TableauClients[1].Depense();
client  1;
pour i de 1 a 10 faire
si ( depense < TableauClient[i].Depense() ) alors
depense  TableauClients[i].Depense();
client  i;
Afficher(« Client ayant fait le plus de dépenses : »);
Afficher(TableauClients[client].Nom());
Afficher(TableauClients[client].Depense());
Fin
Question h)
Algorithme: Magasin.FournisseurPlusLivraisons();
Données: Magasin M1;
Résultat:
//Pas de données de retour , juste de l'affichage
Début
entiers livraisons,i,client;
livraisons  TableauFournisseurs[1].Livraisons();
client  1;
pour i de 2 a 3 faire
si ( livraisons < TableauFournisseurs[i].Livraisons() ) alors
livraisons  TableauFournisseurs[i].Livraisons();
client  i;
Afficher(“Fournisseur ayant effectué le plus de livraisons : “);
Afficher(TableauFournisseurs[client].Nom());
Afficher(TableauFournisseurs[client].Livraisons());
Fin
Question i)
Algorithme: Magasin.ProduitPlusMarge();
Données: Magasin M1;
Résultat:
//Pas de données de retour , juste de l'affichage
Début
entiers marge,i,clients;
marge  TableauProduits[1].Marge();
client  1;
pour i de 2 à 20 faire
si (marge < TableauProduits[i]Marge() ) alors
marge  TableauProduits.Marge();
client  i;
Afficher(« Produits ayant la plus grande marge : »);
Afficher(TableauProduits[client].Nom());
Afficher(TableauProduits[client].Marge());
Fin
Question j)
Algorithme: Magasin.ProduitPlusMarge();
Données: Magasin M1;
Résultat:
//Pas de données de retour , juste de l'affichage
Début
entier i;
Afficher(« Vendeurs ayant effectue plus de 10 ventes : »);
pour i de 1 à 8 faire
si ( TableauEmployes[i].NombreVentes() > 10 ) alors
Afficher(TableauEmployes[i].Nom());
Fin