language c exo

35
Exercice 1 : Correction On désire programmer une application de gestion de produit d’un magasin. Pour cela, on va écrire une structure Produit et une structure Magasin. Chaque produit est caractérisé par son nom (chaine de caractère), son prix d'achat (double), son prix de vente (double) et le nombre d'exemplaires en stock (int). 1. Définir la structure Produit. 2. Définir les fonctions suivantes utilisant la structure Produit : a. void initProduit(Produit * adrP, char n[], double prixA, double prixV) permettant l’initialisation d’un produit avec un nom, un prix d'achat et un prix de vente (c'est-à-dire que ces données son fournies en argument). Par défaut, la quantité de produits en stock est nulle. b. void afficherProduit(Produit p) qui affiche les données d’un produit. c. void modifier(Produit * adrP, double prix) qui permet de modifier le prix de vente d’un produit. d. int egaux(Produit p1, Produit p2) permettant de comparer deux produits (deux produit sont égaux s’ils ont le même nom). e. void ajouterExemplaire(Produit * adrP, int nbExp) permettant d’augmenter le nombre d'exemplaires en stock d’un produit. f. void retirerExemplaire(Produit * adrP, int nbExp) permettant de diminue le nombre d'exemplaires en stock d’un produit. Un magasin se caractérise par son solde (double), un nombre courant de produit dans le magasin et par son stock de produits (adresse vers des Produit). Le stock de produit est représenté par un tableau d’adresse vers des Produit alloué dynamiquement lors de l’initialisation d’un nouveau magasin par une taille donnée en paramètre. Le nombre courant de produit dans le magasin est initialisé à nulle lors de l’initialisation d’un nouveau magasin et incrémenté dans chaque ajout d’un produit au magasin. La structure Magasin aura donc la forme suivante :

Upload: assoumatiazeddine

Post on 08-Jul-2016

12 views

Category:

Documents


0 download

DESCRIPTION

sdfdsfdsfdsdsfd

TRANSCRIPT

Page 1: Language C EXO

Exercice 1 : Correction

On désire programmer une application de gestion de produit d’un magasin. Pour cela, on va écrire une structure Produit et une structure Magasin. Chaque produit est caractérisé par son nom (chaine de caractère), son prix d'achat (double), son prix de vente (double) et le nombre d'exemplaires en stock (int).

1.      Définir la structure Produit.

2.      Définir les fonctions suivantes utilisant la structure Produit :

a.       void initProduit(Produit * adrP, char n[], double prixA, double prixV) permettant l’initialisation d’un produit avec un nom, un prix d'achat et un prix de vente (c'est-à-dire que ces données son fournies en argument). Par défaut, la quantité de produits en stock est nulle.

b.      void afficherProduit(Produit p) qui affiche les données d’un produit.

c.       void modifier(Produit * adrP, double prix) qui permet de modifier le prix de vente d’un produit.

d.      int egaux(Produit p1, Produit p2) permettant de comparer deux produits (deux produit sont égaux s’ils ont le même nom).

e.       void ajouterExemplaire(Produit * adrP, int nbExp) permettant d’augmenter le nombre d'exemplaires en stock d’un produit.

f.       void retirerExemplaire(Produit * adrP, int nbExp) permettant de diminue le nombre d'exemplaires en stock d’un produit.

Un magasin se caractérise par son solde (double), un nombre courant de produit dans le magasin  et par son stock de produits (adresse vers des Produit). Le stock de produit est représenté par un tableau d’adresse vers des Produit alloué dynamiquement lors de l’initialisation d’un nouveau magasin par une taille donnée en paramètre. Le nombre courant de produit dans le magasin est initialisé à nulle lors de l’initialisation d’un nouveau magasin et incrémenté dans chaque ajout d’un produit au magasin. La structure Magasin aura donc la forme suivante :

typedef struct Magasin{    double solde;    int taille;    int nbProduit;    Produit ** tabProd;}Magasin;

Si m est un objet Magasin et p1 et p2 sont deux objets Produit ajoutés aux magasin m alors on aura la configuration suivante :

Page 2: Language C EXO

3.      Définir la fonction permettant d’initialiser un magasin avec un solde sol et une taille t dont le prototype est :

void initMagasin(Magasin * adrM, double sol,  int t);Avant de pouvoir acheter ou vendre un produit, il faut l'avoir ajouté dans le stock. Pour cela, on doit disposer d'une fonction void ajouterProduit (Magasin * adrM, Produit * adrP) et de la méthode int verifierProduit(Magasin m, Produit p) permettant de vérifier si le produit passé en argument existe dans le magasin ou pas (Ne pas ajouter un produit qui existe déjà).

4.      Définir les fonctions verifierProduit et ajouterProduit.

5.      Pour acheter ou vendre ce produit, on utilise alors l’adresse du produit comme argument des fonctions. Définir les deux fonctions suivantes :

void acheterProduit(Magasin * adrM, Produit * adrProd, int nbExemplaires)vendreProduit(Magasin * adrM, Produit * adrProd, int nbExemplaires)6.      Définir également la fonction void getBilan(Magasin m) qui permet d'afficher le bilan du magasin (affichage du stock).

7.      Ecrire un programme main permettant de tester l’ensemble des structures et des fonctions définies précédemment.

Exercice 2 : Correction

On désire programmer une application de gestion des employés d’une entreprise. Pour cela, on va écrire une structure Employe et une structure Entreprise. Chaque employé est caractérisé par son nom (chaine de caractère), sa fonction (chaine de caractère), son salaire (double) et son ancienneté (int) (le nombre d’années de la personne dans l’entreprise).

1.      Ecrire la structure Employe.

2.      Définir les fonctions suivantes :

Page 3: Language C EXO

a.       void initEmploye(...) permettant l’initialisation d’un employé, on fixe son nom, sa fonction, son salaire et son ancienneté (c'est-à-dire que ces données son fournies en argument).

b.      void modifier(...) qui permet de modifier le salaire d’un employé.

c.       int egaux(...) permettant de comparer deux employés (deux employés sont égaux s’ils ont le même nom).

d.      void augmenterAnnee(...) permettant d’augmenter l’ancienneté d’un employé.

e.       void afficherEmploye(...) permettant d’afficher le nom, la fonction, le salaire et l’ancienneté d’un employé.

L’entreprise se caractérise par son nom (chaine de caractères), son chiffre d’affaire (double) et par son staff  d’employés (structure Employe). Le staff d’employé est représenté par un tableau de taille 100 d’adresse vers les employés (Employe * tabEmp[100]) et un nombre d’employé de l’entreprise (int)  initialisé à 0 lors de l’initialisation de l’entreprise, incrémenté à chaque ajout d’un employé à l’entreprise et décrémenté à chaque retrait d’un employé de l’entreprise. Avant de pouvoir ajouter un employé à l’entreprise, il faux le vérifier qu’il n’est pas ajouté déjà au tableau des employés de l’entreprise.

La déclaration de la structure Entreprise sera donc comme suit :

typedef struct Entreprise{

       char nom[50];

       double chiffreAffaire;

       Employe * tabEmp[100];      

       int nbEmp;

}Entreprise;3.      Ecrire la structure Entreprise4.      Définir les fonctions suivantes :

a.       void initEntreprise(...) permettant l’initialisation d’une entreprise.

b.      int verifier(...) permettant de vérifier si un employé passé en argument existe dans une entreprise ou pas.

c.       void ajouterEmploye(...) permettant d’ajouter un employé passé au paramètre au tableau des employés de l’entreprise s’il n’existe pas.

d.      void retirerEmploye(...) permettant de libérer (supprimer) un employé passé en paramètre du tableau des employés de l’entreprise s’il existe.

e.       void afficherEntreprise(...) permettant d'afficher l’ensemble des employés de l’entreprise.

Page 4: Language C EXO

5.      Ecrire un programme main permettant de tester l’ensemble des structures et des fonctions définies précédemment.

Exercice 3 : Correction

Définir une structure Polynome, qui représente un polynôme de degré n, par ses coefficients enregistrés dans un tableau dynamique de n + 1 nombres réels (float) et le champ Degre représentant le degré du polynôme (le plus grand exposant de X dont le coefficient n'est pas nul). Par exemple, le polynôme de degré 4 : A(X) = 9.5*X4 - 7*X3 + 1.5*X - 2.8, sera représenté par le champ Degre = 4, et par le tableau Coef = {−2.8, 1.5, 0, −7, 9.5} de taille 5, où coef[i] est le coefficient de Xi.

On souhaite définir les fonctions suivantes :

1.      La fonction void initPoly(Polynome * adrP, float tabC[], int t) qui permet d’initialiser l’objet polynôme d’adresse p par le tableau de nombres réels tabC de taille t.

Par exemple : Si T est un tableau qui contient les valeurs {−2.8, 1.5, 0, −7, 9.5}, l’objet polynôme A donné comme exemple sera initialisé par l’appel de : Polynome A;        initPoly (&A, T, 5);2.      La fonction void detruirePoly(Polynome * adrP) qui permet de détruire le tableau dynamique de coefficients du polynôme d’adresse adrP.

3.      La fonction float valPoly(Polynome p, float X) qui calcule la valeur du polynôme p pour une valeur de X donnée. Cette fonction calculera pour le polynôme A la valeur A(3) = 9.5* 34 – 7*33 + 1.5*X - 2.8 = 582.2 par l’instruction :

float v = valPoly(A, 3);4.      La fonction Polynome somme(Polynome p1, Polynome p2) qui permet de retourner le polynôme somme des deux polynômes p1 et p2.

5.      La fonction Polynome produitReel(Polynome p, float x) qui permet de retourner le polynôme produit d’un polynôme et un réel x.

6.      La fonction Polynome derivee(Polynome p) qui permet de retourne le polynôme dérivée du polynôme p.

Par exemple, la dérivée du polynôme A de l'exemple sera :

(9.5*4)*X3 – (7*3)*X2 + 1.5.

N.B. : La dérivée de a*Xb étant a*b*Xb-1.

7.      La fonction void afficher(Polynome p) qui permet d’afficher le polynôme p sous la forme : 9.5*X^4 – 7*X^3 + 1.5*X – 2.8

Exercice 4 : Correction

On veut écrire un programme permettant de gérer l’ensemble des livres contenus dans une bibliothèque. Pour chaque livre, on conserve les informations suivantes :

-          le code du livre (code : long),

-          le titre du livre (titre : chaine de caractères),

Page 5: Language C EXO

-          le nom de l’auteur (auteur : chaine de caractères),

-          le nombre d’exemplaires (nbExpl : long).

On souhaite gérer une bibliothèque permettant de contenir un nombre quelconque de livres (non prédéfini). On veut de plus concevoir une structure permettant de faciliter le classement des livres dans la bibliothèque.

Types et fonctions de bases

1.      Définir le type Livre qui représente correctement un livre.

2.      Définir la fonction void initLivre(Livre * adrLiv, int c, char t[], char a[], int nbE) permettant d’initialiser le code, le titre, l’auteur et le nombre d’exemplaire d’un livre.

3.      Définir la fonction void afficherLivre(Livre liv) qui permet d’afficher le contenu d’un livre sous forme :

code      titre      nom de l'auteur    nombre exemplaire

4.      Définir une fonction permettant de comparer deux livres passés en paramètres. Deux livres sont égaux s’ils ont le même code et le même titre.

Remarque : Vous pouvez utiliser la fonction strcmp de la bibliothèque <string.h> qui permet de comparer une chaînes s1 et une chaîne s2. La fonction retourne une valeur négative si s1<s2, nulle si s1=s2 et une valeur positive si s1>s2.  Le prototype de la fonction est :

int strcmp (const char *s1, const char *s2);

5.      Expliquez pourquoi une liste chaînée est une solution élégante à ce problème.

6.      Ecrivez la structure Noeud d’une telle liste, chaque nœud représente un livre de la bibliothèque.

Ajout d’un Livre

7.      Ecrivez une fonction  qui permet de vérifier si un livre est dans une bibliothèque, représenté par une liste de Noeud de livre, ou non.

int existeLivre(Noeud * bib, Livre liv) : la fonction retourne 1 si le livre existe dans la liste, 0 sinon.

8.      Ecrivez une fonction void ajouterLivre(Noeud ** adrBib, Livre liv) qui permet d'ajouter un livre à la fin de liste si le livre n’existe pas dans la liste, sinon il augmente le nombre d’exemplaires de ce livre.

Fonction de recherche

Page 6: Language C EXO

9.      Définir une fonction qui affiche tous les livres d’une bibliothèque dont l’auteur est passé en paramètre void afficherLivresAuteur(Noeud * bib, char auteur[]).

10.  Définir une  fonction  int nbrLivresAuteur(Noeud * bib, char auteur[])  qui  permet  de  renvoyer  le nombre de livres d'un auteur passé en paramètre.

11.  Définir une fonction int nbExemplairesBib(Noeud * bib) qui permet de renvoyer le nombre d’exemplaire de l’ensemble des livres de la bibliothèque.

12.  Définir une fonction Noeud * fusionnerBibliotheque(Noeud * bib1, Noeud * bib2) qui permet de renvoyer la fusion de deux liste de livre (bibliothèque) passés en paramètre. La fusion résultante ne doit pas comporter des livres en double.

Triage

13.  Ecrivez une  fonction void trierLivres(Noeud ** adrBib)  qui  permet  de trier les livres d'une bibliothèque en ordre croissant des codes des livres.

Fichiers

14.  Définir les fonctions suivantes permettant de sauvegarder et de restituer les données de la bibliothèque :

a.   void enregisterLivre(Livre liv, char fichLivre[]) : qui permet d’enregistrer le livre passé en paramètre dans le fichier de données binaire fichLivre.

b.   int nombreLivres(char fichLivre[]) : qui permet de retourner le nombre de livres enregistrés dans le fichier fichLivre.

c.    void listerLivres(char fichLivre[]) : qui permet d’afficher l’ensemble des livres enregistrés dans le fichier de données binairefichLivre.

d.  void recupererLivres(char fichLivre[], Noeud ** adrB) : qui permet de récupérer l’ensemble des livres enregistrés dans le fichier de données binaire fichLivre et les  stocker dans une liste de livre.

Page 7: Language C EXO

Exercice Sup 1 Correction

 #include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <string.h>

 

typedef struct Produit{

    char nom[20];

    float prixAchat;

    float prixVente;

    unsigned nbExemp;

}Produit;

 

void initProduit(Produit * adrP, char n[], double prixA, double prixV){

    strcpy(adrP->nom, n);

    adrP->prixAchat = prixA;

    adrP->prixVente = prixV;

    adrP->nbExemp = 0;

}

 

void afficherProduit(Produit p){

    printf("%s\t%.2f\t%.2f\t%d\n", p.nom, p.prixAchat, p.prixVente, p.nbExemp);

Page 8: Language C EXO

}

 

void modifier(Produit * adrP, double prix){

    adrP->prixVente = prix;

}

 

int egaux(Produit p1, Produit p2){

    if(strcmp(p1.nom, p2.nom)==0)

        return 1;

    return 0;

    // return (strcmp(p1.nom, p2.nom)==0) ? 1 : 0;

}

 

void ajouterExemplaire(Produit * adrP, int nbExp){

    adrP->nbExemp += nbExp;

}

 

void retirerExemplaire(Produit * adrP, int nbExp){

    adrP->nbExemp -= nbExp;   

}

 

typedef struct Magasin{

    double solde;

    int taille;

    int nbProduit;

    Produit ** tabProd;

}Magasin;

Page 9: Language C EXO

 

void initMagasin(Magasin * adrM, double sol, int t){

    adrM->solde = sol;

    adrM->taille = t;

    adrM->nbProduit = 0;

    adrM->tabProd = (Produit **)malloc(adrM->taille * sizeof(Produit*));

}

 

int verifierProduit(Magasin m, Produit p){

    int i;

    for(i=0;i<m.nbProduit;i++){

        if(egaux(*(m.tabProd[i]), p) == 1)

            return i;

    }

    return -1;

}

 

void ajouterProduit (Magasin * adrM, Produit * adrP){

    if(verifierProduit(*adrM, *adrP)==-1 && adrM->nbProduit<adrM->taille){

        adrM->tabProd[adrM->nbProduit ++] = adrP;

    }

    else

        printf("Le produit existe deja !!!!\n");

}

 

void vendreProduit(Magasin * adrM, Produit * adrP, int nbExemplaires){

    int pos = verifierProduit(*adrM, *adrP);

Page 10: Language C EXO

    if(pos!=-1 && adrM->tabProd[pos]->nbExemp >= nbExemplaires){

        retirerExemplaire(adrM->tabProd[pos], nbExemplaires);

        adrM->solde += adrP->prixVente * nbExemplaires;

    }

}

 

void achatProduit(Magasin * adrM, Produit * adrP, int nbExemplaires){

    int pos = verifierProduit(*adrM, *adrP);

    if(pos!=-1 && adrM->solde >= adrP->prixAchat * nbExemplaires){

        ajouterExemplaire(adrM->tabProd[pos], nbExemplaires);

        adrM->solde -= adrP->prixAchat * nbExemplaires;

    }

    else

        ajouterProduit(adrM, adrP);

}

 

void getBilan(Magasin m){

    int i;

    if(m.nbProduit>0){

        printf("Magasin avec un solde de : %2.f dh\n", m.solde);

        printf("Le magasin contient %d produits :\n", m.nbProduit);

        for(i=0;i<m.nbProduit;i++)

            afficherProduit(*(m.tabProd[i]));

    }

    else

        printf("Magasin vide !!!!\n");

}

Page 11: Language C EXO

 

main(){

    Magasin mag;

    Produit p1, p2, p3;

   

    initMagasin(&mag, 20000, 10);

    initProduit(&p1, "Table", 200, 250);

    initProduit(&p2, "Chaise", 50, 70);

    initProduit(&p3, "Papier", 20, 25);

   

    ajouterProduit(&mag, &p1);

    ajouterProduit(&mag, &p2);

   

    achatProduit(&mag, &p1, 5);

    vendreProduit(&mag, &p1, 2);

    achatProduit(&mag, &p3, 4);

   

    getBilan(mag);

   

    getch();   

}

Page 12: Language C EXO

Exercice Sup 2 Correction

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <string.h>

 

typedef struct Employe{

    char nom[20];

    char fonction[20];

    double salaire;

    int anciennete;

}Employe;

 

void initEmploye(Employe * adrE, char n[], char f[], double s, int a){

    strcpy(adrE->nom, n);

    strcpy(adrE->fonction, f);

    adrE->salaire = s;

    adrE->anciennete = a;

}

 

void modifier(Employe * adrE, double s){

    adrE->salaire = s;

Page 13: Language C EXO

}

 

int egaux(Employe e1, Employe e2){

    return (strcmp(e1.nom, e2.nom)==0 ? 1 : 0);

}

 

void augmenterAnnee(Employe * adrE){

    adrE->anciennete ++;

}

 

void afficherEmploye(Employe e){

    printf("%s est un %s, Salaire : %.2f dh d'une anciennete de %d ans\n",

                                        e.nom, e.fonction, e.salaire, e.anciennete);

}

 

typedef struct Entreprise{

       char nom[50];

       double chiffreAffaire;

       Employe * tabEmp[100];     

       int nbEmp;

}Entreprise;

 

void initEntreprise(Entreprise * adrEt, char n[], double ca){

    strcpy(adrEt->nom, n);

    adrEt->chiffreAffaire = ca;

    adrEt->nbEmp = 0;

}

Page 14: Language C EXO

 

int verifier(Entreprise et, Employe e){

    int i;

    for(i=0;i<et.nbEmp;i++){

        if(egaux(*(et.tabEmp[i]), e))

            return i;   

    }

    return -1;

}

 

void ajouterEmploye(Entreprise * adrEt, Employe * adrE){

    if(verifier(*adrEt, *adrE)==-1 && adrEt->nbEmp<100){

        adrEt->tabEmp[adrEt->nbEmp ++ ] = adrE;   

    }

}

 

void retirerEmploye(Entreprise * adrEt, Employe * adrE){

    int i;

    int pos = verifier(*adrEt, *adrE);   // position de l'employe dans le tableau des employes

    if(pos!=-1 && adrEt->nbEmp>0){

        for(i=pos;i<adrEt->nbEmp;i++)

            adrEt->tabEmp[i] = adrEt->tabEmp[i+1];

        adrEt->nbEmp --;

    }

}

 

void afficherEntreprise(Entreprise et){

Page 15: Language C EXO

    int i;

    if(et.nbEmp>0){

        for(i=0;i<et.nbEmp;i++){

            afficherEmploye(*(et.tabEmp[i]));   

        }

    }

    else

        printf("Entreprise vide !!!!\n");

}

main(){

    Employe a, b, c, d;

    initEmploye(&a, "Adnane", "Directeur", 30000, 5);

    initEmploye(&b, "Hamid", "Ingenieur", 1000, 2);

    initEmploye(&c, "Aicha", "Secretaire", 3000, 4);

    initEmploye(&d, "Kamal", "Technicien", 30000, 2);

   

    Entreprise entr;

    initEntreprise(&entr, "Socaca", 1000000);

    afficherEntreprise(entr);

   

    ajouterEmploye(&entr, &a);

    ajouterEmploye(&entr, &b);

    ajouterEmploye(&entr, &c);

    ajouterEmploye(&entr, &d);

   

    afficherEntreprise(entr);

   

Page 16: Language C EXO

    printf("Suppression de Hamid\n");

   

    retirerEmploye(&entr, &b);

   

    afficherEntreprise(entr);

   

    getch();   

}

Page 17: Language C EXO

Exercice Sup 3 : Correction

 #include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

 

typedef struct Polynome{

    float * coeff;

    int degre;

}Polynome;

 

void initPoly(Polynome * adrP, float c[], int t){

    int i;

    adrP->degre = t - 1;

    adrP->coeff = (float*)malloc(t * sizeof(float));

    for(i=0;i<t;i++){

        adrP->coeff[i] = c[i];

    }

}

 

void detruirePoly(Polynome * adrP){

Page 18: Language C EXO

    free(adrP->coeff);

}

 

float valPoly(Polynome p, float X){

    float v = 0;

    int i;

    for(i=0;i<p.degre+1;i++){

        v += p.coeff[i] * pow(X, i);

    }   

    return v;

}

 

Polynome somme(Polynome p1, Polynome p2){

    Polynome som;

    int i = 0, j = 0, k = 0;

    som.degre = (p1.degre > p2.degre) ? p1.degre : p2.degre;

    float * c;

    c = (float*)calloc(sizeof(float), (som.degre + 1));

    while((i<(p1.degre+1)) && (j<(p2.degre+1))){

        c[k++] = p1.coeff[i++] + p2.coeff[j++];

    }

    while(i<(p1.degre+1)){

        c[k++] = p1.coeff[i++];

    }

    while(j<(p2.degre+1)){

        c[k++] = p2.coeff[j++];

    }

Page 19: Language C EXO

    initPoly(&som, c, (som.degre) + 1);

    return som;

}

 

Polynome produitReel(Polynome p, float x){

    Polynome pr;

    int i;

    initPoly(&pr, p.coeff, p.degre+1);

    for(i=0;i<pr.degre+1;i++)

        pr.coeff[i] *= x;

    return pr;

}

 

Polynome derivee(Polynome p){

    Polynome d;

    float * c = (float*)calloc(sizeof(float), p.degre);

    int i;

    for(i=0;i<p.degre;i++)

        c[i] = p.coeff[i+1] * (i+1);

    initPoly(&d, c, p.degre);

    return d;

}

 

void afficher(Polynome p){

    int i;

    printf("%.1f * X^%d", p.coeff[p.degre], p.degre);

    for(i=p.degre-1;i>=0;i--){

Page 20: Language C EXO

        if(p.coeff[i]>=0){

            printf(" +%.1f", p.coeff[i]);

        }

        else{

            printf(" %.1f", p.coeff[i]);

        }

        if(i>1){

            printf(" * X^%d", i);

        }

        else{

            if(i==1){

                printf(" * X");

            }

        }

    }

    printf("\n\n");

}

 

main(){

    Polynome A, B, C, D, E;

    float c1[] = {-2.8, 1.5, 0, -7, 9.5};

    float c2[] = {4, 9, 3, 5};

    initPoly(&A, c1, 5);

    initPoly(&B, c2, 4);

    printf("A(X) = "); afficher(A);

    printf("B(X) = "); afficher(B);

    C = somme(A,B);

Page 21: Language C EXO

    printf("C(X) = "); afficher(C);

    printf("A(3) = %.1f\n\n", valPoly(A, 3));

    D = produitReel(C, 2);

    printf("D(X) = "); afficher(D);

    E = derivee(A);

    printf("E(X) = "); afficher(E);

    getch();

}

Page 22: Language C EXO

Exercice Sup 4 Correction

 #include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#include <string.h>

 

// Definition du type boolean

// FAUX = 0 et VRAI = 1

typedef enum BOOL{FAUX,VRAI}BOOL;

 

typedef struct Livre{

    long code;

    char titre[20];

    char auteur[20];

    long nbExemp;

}Livre;

 

void initLivre(Livre * adrLiv, int c, char t[], char a[], int nbE){

    adrLiv->code = c;

    strcpy(adrLiv->titre, t);

    strcpy(adrLiv->auteur, a);

    adrLiv->nbExemp = nbE;

Page 23: Language C EXO

}

 

void afficherLivre(Livre liv){

    printf("Livre : %d %s %s %d\n", liv.code, liv.titre, liv.auteur, liv.nbExemp);

}

 

BOOL comparerLivre(Livre liv1, Livre liv2){

    if(liv1.code == liv2.code && strcmp(liv1.titre, liv2.titre)==0)

        return VRAI;

    return FAUX;

}

 

// Question 5

/*

   La liste chainée est extensible et ne nécéssite pas de taille fixe.

*/

 

typedef struct Noeud{

    Livre li;

    struct Noeud * suiv;

}Noeud;

 

BOOL existeLivre(Noeud * bib, Livre liv){

    while(bib != NULL){

        if(comparerLivre(bib->li, liv)==VRAI)

            return VRAI;

        bib = bib->suiv;

Page 24: Language C EXO

    }

    return FAUX;

}

 

void ajouterLivre(Noeud ** adrBib, Livre liv){

    if(existeLivre(*(adrBib), liv)==FAUX){

        Noeud * n;

        n = (Noeud*)malloc(sizeof(Noeud));

        n->li = liv;

        n->suiv = (*adrBib);

        (*adrBib) = n;

    }

}

 

void afficherLivreBib(Noeud * bib){

    if(bib!=NULL){

        while(bib!=NULL){

            afficherLivre(bib->li);

            bib = bib->suiv;

        }

    }

    else

        printf("Pas de livre dans cette bibliotheque !!!\n");

}

 

void afficherLivresAuteur(Noeud * bib, char auteur[]){

    if(bib!=NULL){

Page 25: Language C EXO

        while(bib!=NULL){

            if(strcmp(bib->li.auteur, auteur)==0){

                afficherLivre(bib->li);

            }

            bib = bib->suiv;

        }

    }

    else

        printf("Pas de livre dans cette bibliotheque !!!\n");

}

 

int nbrLivresAuteur(Noeud * bib, char auteur[]){

    int nbLivre = 0;

    if(bib!=NULL){

        while(bib!=NULL){

            if(strcmp(bib->li.auteur, auteur)==0){

                nbLivre ++;

            }

            bib = bib->suiv;

        }

    }

    return nbLivre;

}

 

int nbExemplairesBib(Noeud * bib){

    int nbE = 0;

    if(bib!=NULL){

Page 26: Language C EXO

        while(bib!=NULL){

            nbE += bib->li.nbExemp;

            bib = bib->suiv;

        }

    }

    return nbE;

}

 

Noeud * fusionnerBibliotheque(Noeud * bib1, Noeud * bib2){

    Noeud * bibF = NULL;

    // Remarquer que la fonction ajouterLivre n'ajoute pas les livres en double

    while(bib1!=NULL){

            ajouterLivre(&bibF, bib1->li);

            bib1 = bib1->suiv;

    }   

    while(bib2!=NULL){

            ajouterLivre(&bibF, bib2->li);

            bib2 = bib2->suiv;

    }

    return bibF;

}

 

void trierLivres(Noeud ** adrB){

    Noeud * nCurr = (*adrB);

    Noeud * nSuiv;

    Livre tmp;

    while(nCurr->suiv != NULL){

Page 27: Language C EXO

        nSuiv = nCurr->suiv;

        while(nSuiv != NULL){

            if(nSuiv->li.code < nCurr->li.code){

                tmp = nSuiv->li;

                nSuiv->li = nCurr->li;

                nCurr->li = tmp;

            }

            nSuiv = nSuiv->suiv;

        }

        nCurr = nCurr->suiv;

    }

}

 

void enregisterLivre(Livre liv, char fichLivre[]){

    FILE * pF;

    pF = fopen(fichLivre, "ab+");

    if(pF==NULL){

        printf("Impossible d'ouvrir le fichier %s\n", fichLivre);

        exit(1);   

    }

    fwrite(&liv, sizeof(Livre), 1, pF);

    fclose(pF);

}

 

int nombreLivres(char fichLivre[]){

    FILE * pF;

    pF = fopen(fichLivre, "rb");

Page 28: Language C EXO

    if(pF==NULL){

        printf("Impossible d'ouvrir le fichier %s\n", fichLivre);

        exit(1);   

    }

    fseek(pF, 0, SEEK_END);

    long taille = ftell(pF);

    int nbLivre = taille / sizeof(Livre);       

    return nbLivre;

}

 

void listerLivres(char fichLivre[]){

    Livre * tabL;

    int i;

    int n = nombreLivres(fichLivre);   

    tabL = (Livre*)malloc(n * sizeof(Livre));

    FILE * pF;

    pF = fopen(fichLivre, "rb");

    if(pF==NULL){

        printf("Impossible d'ouvrir le fichier %s\n", fichLivre);

        exit(1);   

    }

    fread(tabL, sizeof(Livre), n, pF);

    for(i=0;i<n;i++){

        afficherLivre(tabL[i]);

        printf("\n");   

    }

    fclose(pF);

Page 29: Language C EXO

    free(tabL);

}

 

void recupererLivres(char fichLivre[], Noeud ** adrB){   

    Livre * tabL;

    int i;

    int n = nombreLivres(fichLivre);   

    tabL = (Livre*)malloc(n * sizeof(Livre));

    FILE * pF;

    pF = fopen(fichLivre, "rb");

    if(pF==NULL){

        printf("Impossible d'ouvrir le fichier %s\n", fichLivre);

        exit(1);   

    }

    fread(tabL, sizeof(Livre), n, pF);

    for(i=0;i<n;i++){

        ajouterLivre(adrB, tabL[i]);

    }

    fclose(pF);

    free(tabL);

}

main(){

    Livre A, B, C, D, E, F;

    Noeud * BIBLIO1 = NULL;

    Noeud * BIBLIO2 = NULL;

    Noeud * BIBLIOFus = NULL;

    Noeud * BibFromFichier = NULL;

Page 30: Language C EXO

   

    initLivre(&A, 111, "Programmation C", "Claude Delanauy", 10);

    initLivre(&B, 222, "Bases de Donnees", "George Gardarin", 20);

    initLivre(&C, 333, "Resaux", "Tanaumbom", 40);

    initLivre(&D, 444, "Programmation OO", "Claude Delanauy", 10);

    initLivre(&E, 555, "Maths", "MMMMM", 50);

    initLivre(&F, 666, "Physique", "PPPPPP", 15);

   

    ajouterLivre(&BIBLIO1, A);

    ajouterLivre(&BIBLIO1, B);

    ajouterLivre(&BIBLIO1, A);

    ajouterLivre(&BIBLIO1, C);

    ajouterLivre(&BIBLIO1, D);

   

    ajouterLivre(&BIBLIO2, B);

    ajouterLivre(&BIBLIO2, E);

    ajouterLivre(&BIBLIO2, F);

   

    printf("\nAffichage des livres de la bibliothèque BIBLIO1\n\n");

    afficherLivreBib(BIBLIO1);

    printf("\nAffichage des livres de Claude Delanauy\n\n");

    afficherLivresAuteur(BIBLIO1, "Claude Delanauy");

   

    printf("\nLe nombre de livre de Claude Delanauy est : %d\n\n", nbrLivresAuteur(BIBLIO1, "Claude Delanauy"));

   

    printf("\nLe nombre d'exrmplaire de la bibliotheque est : %d\n\n", nbExemplairesBib(BIBLIO1));

Page 31: Language C EXO

   

    BIBLIOFus = fusionnerBibliotheque(BIBLIO1, BIBLIO2);

   

    printf("\nAffichage des livres de la bibliothèque BIBLIOFus\n\n");

    afficherLivreBib(BIBLIOFus);

   

    printf("\nAffichage triee des livres de la bibliothèque BIBLIOFus\n\n");

    trierLivres(&BIBLIOFus);

    afficherLivreBib(BIBLIOFus);

   

    /*

    enregisterLivre(A, "mesLivres.data");

    enregisterLivre(B, "mesLivres.data");

    enregisterLivre(C, "mesLivres.data");

    */

   

    recupererLivres("mesLivres.data", &BibFromFichier);

    printf("\n\nAffichage des livres recuperes :\n\n");

    afficherLivreBib(BibFromFichier);

   

    getch();   

}