Vous êtes sur la page 1sur 31

Exercice 1 : Correction

On dsire programmer une application de gestion de produit dun magasin. Pour cela, on va
crire une structure Produit et une structure Magasin. Chaque produit est caractris par
son nom (chaine de caractre), son prix d'achat (double), son prix de vente
(double) et le nombre d'exemplaires en stock (int).
1. Dfinir la structure Produit.
2. Dfinir les fonctions suivantes utilisant la structure Produit :
a. void initProduit(Produit * adrP, char n[], double
prixA, double prixV) permettant linitialisation dun produit avec un
nom, un prix d'achat et un prix de vente (c'est--dire que ces donnes son
fournies en argument). Par dfaut, la quantit de produits en stock est nulle.
b. void afficherProduit(Produit p) qui affiche les donnes dun
produit.
c. void modifier(Produit * adrP, double prix) qui permet de
modifier le prix de vente dun produit.
d. int egaux(Produit p1, Produit p2) permettant de comparer
deux produits (deux produit sont gaux sils ont le mme nom).
e. void
ajouterExemplaire(Produit
*
adrP,
int
nbExp) permettant daugmenter le nombre d'exemplaires en stock dun
produit.
f. void
retirerExemplaire(Produit
*
adrP,
int
nbExp) permettant de diminue le nombre d'exemplaires en stock dun
produit.
Un magasin se caractrise 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
reprsent par un tableau dadresse vers des Produit allou dynamiquement lors de
linitialisation dun nouveau magasin par une taille donne en paramtre. Le nombre courant
de produit dans le magasin est initialis nulle lors de linitialisation dun nouveau magasin et
incrment dans chaque ajout dun 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
magasin m alors on aura la configuration suivante :

deux

objets Produit ajouts

aux

3. Dfinir la fonction permettant dinitialiser 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 mthode int verifierProduit(Magasin m, Produit
p) permettant de vrifier si le produit pass en argument existe dans le magasin ou pas (Ne
pas ajouter un produit qui existe dj).
4. Dfinir les fonctions verifierProduit et ajouterProduit.
5. Pour acheter ou vendre ce produit, on utilise alors ladresse du produit comme
argument des fonctions. Dfinir les deux fonctions suivantes :
void acheterProduit(Magasin * adrM, Produit * adrProd, int
nbExemplaires)
vendreProduit(Magasin
nbExemplaires)

adrM,

Produit

adrProd,

int

6. Dfinir 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 lensemble des structures et des
fonctions dfinies prcdemment.
Exercice 2 : Correction
On dsire programmer une application de gestion des employs dune entreprise. Pour cela,
on va crire une structure Employe et une structure Entreprise. Chaque employ est
caractris par son nom (chaine de caractre), sa fonction (chaine de
caractre), son salaire (double) et son anciennet (int) (le nombre dannes de la
personne dans lentreprise).
1. Ecrire la structure Employe.
2. Dfinir les fonctions suivantes :

a. void initEmploye(...) permettant linitialisation dun employ, on


fixe son nom, sa fonction, son salaire et son anciennet (c'est--dire que ces
donnes son fournies en argument).
b. void modifier(...) qui permet de modifier le salaire dun employ.
c. int egaux(...) permettant de comparer deux employs (deux employs
sont gaux sils ont le mme nom).
d. void augmenterAnnee(...) permettant daugmenter lanciennet
dun employ.
e. void afficherEmploye(...) permettant dafficher le nom, la
fonction, le salaire et lanciennet dun employ.
Lentreprise se caractrise par son nom (chaine de caractres), son chiffre daffaire
(double) et par son staff demploys (structure Employe). Le staff demploy est
reprsent par un tableau de taille 100 dadresse vers les employs (Employe *
tabEmp[100]) et un nombre demploy de lentreprise (int) initialis 0 lors de
linitialisation de lentreprise, incrment chaque ajout dun employ lentreprise et
dcrment chaque retrait dun employ de lentreprise. Avant de pouvoir ajouter un
employ lentreprise, il faux le vrifier quil nest pas ajout dj au tableau des employs
de lentreprise.
La dclaration 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 Entreprise
4. Dfinir les fonctions suivantes :
a.

void initEntreprise(...) permettant linitialisation dune entreprise.

b. int verifier(...) permettant de vrifier si un employ pass en


argument existe dans une entreprise ou pas.
c. void ajouterEmploye(...) permettant dajouter un employ pass
au paramtre au tableau des employs de lentreprise sil nexiste pas.
d. void retirerEmploye(...) permettant de librer (supprimer) un
employ pass en paramtre du tableau des employs de lentreprise sil existe.
e. void afficherEntreprise(...) permettant d'afficher lensemble des
employs de lentreprise.

5. Ecrire un programme main permettant de tester lensemble des structures et des


fonctions dfinies prcdemment.
Exercice 3 : Correction
Dfinir une structure Polynome, qui reprsente un polynme de degr n, par ses
coefficients enregistrs dans un tableau dynamique de n + 1 nombres rels (float) et le
champ Degre reprsentant le degr du polynme (le plus grand exposant de X dont le
coefficient n'est pas nul). Par exemple, le polynme de degr 4 : A(X) = 9.5*X4 - 7*X3 +
1.5*X - 2.8, sera reprsent 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 dfinir les fonctions suivantes :
1. La fonction void initPoly(Polynome * adrP, float tabC[], int
t) qui permet dinitialiser lobjet polynme dadresse p par le tableau de nombres
rels tabC de taille t.
Par exemple : Si T est un tableau qui contient les valeurs {2.8, 1.5, 0, 7,
9.5}, lobjet polynme A donn comme exemple sera initialis par lappel
de : Polynome A;
initPoly (&A, T, 5);
2. La fonction void detruirePoly(Polynome * adrP) qui permet de
dtruire le tableau dynamique de coefficients du polynme dadresse adrP.
3. La fonction float valPoly(Polynome p, float X) qui calcule la valeur
du polynme p pour une valeur de X donne. Cette fonction calculera pour le
polynme A la valeur A(3) = 9.5* 34 7*33 + 1.5*X - 2.8 = 582.2 par linstruction :
float v = valPoly(A, 3);
4. La fonction Polynome somme(Polynome p1, Polynome p2) qui
permet de retourner le polynme somme des deux polynmes p1 et p2.
5. La fonction Polynome produitReel(Polynome p, float x) qui
permet de retourner le polynme produit dun polynme et un rel x.
6. La fonction Polynome derivee(Polynome p) qui permet de retourne le
polynme drive du polynme p.
Par exemple, la drive du polynme A de l'exemple sera :
(9.5*4)*X3 (7*3)*X2 + 1.5.
N.B. : La drive de a*Xb tant a*b*Xb-1.
7. La fonction void afficher(Polynome p) qui permet dafficher le
polynme 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 grer lensemble des livres contenus dans une
bibliothque. Pour chaque livre, on conserve les informations suivantes :
-

le code du livre (code : long),

le titre du livre (titre : chaine de caractres),

le nom de lauteur (auteur : chaine de caractres),

le nombre dexemplaires (nbExpl : long).

On souhaite grer une bibliothque permettant de contenir un nombre quelconque de livres


(non prdfini). On veut de plus concevoir une structure permettant de faciliter le classement
des livres dans la bibliothque.
Types et fonctions de bases
1. Dfinir le type Livre qui reprsente correctement un livre.
2. Dfinir la fonction void initLivre(Livre * adrLiv, int c, char t[], char
a[], int nbE) permettant dinitialiser le code, le titre, lauteur et le nombre dexemplaire
dun livre.
3. Dfinir la fonction void afficherLivre(Livre liv) qui permet dafficher le contenu
dun livre sous forme :
code

titre

nom de l'auteur

nombre exemplaire

4. Dfinir une fonction permettant de comparer deux livres passs en paramtres. Deux
livres sont gaux sils ont le mme code et le mme titre.
Remarque : Vous pouvez utiliser la fonction strcmp de la bibliothque <string.h> qui
permet de comparer une chanes s1 et une chane s2. La fonction retourne une valeur
ngative 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 chane est une solution lgante ce problme.
6. Ecrivez la structure Noeud dune telle liste, chaque nud reprsente un livre de la
bibliothque.
Ajout dun Livre
7. Ecrivez une fonction qui permet de vrifier si un livre est dans une bibliothque,
reprsent 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 nexiste pas dans la liste, sinon il augmente
le nombre dexemplaires de ce livre.
Fonction de recherche

9. Dfinir une fonction qui affiche tous les livres dune bibliothque dont lauteur est pass
en paramtre void afficherLivresAuteur(Noeud * bib, char auteur[]).
10. Dfinir une fonction int nbrLivresAuteur(Noeud * bib, char auteur[])
qui permet de renvoyer le nombre de livres d'un auteur pass en paramtre.
11. Dfinir une fonction int nbExemplairesBib(Noeud * bib) qui permet de
renvoyer le nombre dexemplaire de lensemble des livres de la bibliothque.
12. Dfinir une fonction Noeud * fusionnerBibliotheque(Noeud * bib1,
Noeud * bib2) qui permet de renvoyer la fusion de deux liste de livre (bibliothque)
passs en paramtre. La fusion rsultante 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 bibliothque en ordre croissant des codes des livres.
Fichiers
14. Dfinir les fonctions suivantes permettant de sauvegarder et de restituer les donnes de la
bibliothque :
a. void enregisterLivre(Livre liv, char fichLivre[]) : qui
permet denregistrer le livre pass en paramtre dans le fichier de donnes
binaire fichLivre.
b. int nombreLivres(char fichLivre[]) : qui permet de retourner le
nombre de livres enregistrs dans le fichier fichLivre.
c. void listerLivres(char fichLivre[]) : qui permet dafficher
lensemble des livres enregistrs dans le fichier de donnes binairefichLivre.
d. void recupererLivres(char fichLivre[], Noeud **
adrB) : qui permet de rcuprer lensemble des livres enregistrs dans le
fichier de donnes binaire fichLivre et les stocker dans une liste de livre.

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

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;

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

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

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

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

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){


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

printf("Suppression de Hamid\n");

retirerEmploye(&entr, &b);

afficherEntreprise(entr);

getch();
}

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){


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++];
}
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--){
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);
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();
}

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

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 chaine est extensible et ne ncssite 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;
}

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){
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){
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){
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");
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);
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;

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 bibliothque 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));

BIBLIOFus = fusionnerBibliotheque(BIBLIO1, BIBLIO2);

printf("\nAffichage des livres de la bibliothque BIBLIOFus\n\n");


afficherLivreBib(BIBLIOFus);

printf("\nAffichage triee des livres de la bibliothque 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();
}