Introduction

Objectif du projet : Fournir un système de gestion de bibliothèque pour les collèges

bibliothèque, cela fournirait toutes les fonctions de la bibliothèque.

Rationale : Améliorer les services d'utilisation des bibliothèques et réduire la paperasse.

Scope of Project:

Rendre le système existant plus efficace.

Pour offrir un environnement convivial où l'utilisateur peut être
mieux servi.
Rendre le fonctionnement de la bibliothèque plus rapide.
Fournir un système où le personnel de la bibliothèque peut attraper les débiteurs.
et ne les laisser pas s'échapper.
Minimiser les pertes subies par les livres.

Page | 1
 Modèle de processus utilisé

Dans mon projet, j'ai utilisé le modèle en cascade. Ce modèle est utilisé lorsque
les exigences sont bien définies et raisonnablement stables, et dans mon projet
Le système de gestion des bibliothèques, toutes les exigences sont bien définies.

Le modèle en cascade, parfois appelé cycle de vie classique, suggère un

une approche systématique et séquentielle du développement logiciel qui commence par
spécification des exigences client et progrès par le biais de la planification,
modélisation, construction et déploiement, aboutissant à un soutien continu de
le logiciel complet.

J'ai défini des activités et les ai représentées dans des phases de processus séparées.
Toutes les étapes se chevauchent et se nourrissent d'informations les unes des autres. Ce n'est pas simple.
modèle linéaire mais implique une séquence d'itérations d'activités de développement.

Ce modèle est approprié pour mon projet car j'avais beaucoup de temps pour
la conception, donc les contraintes de temps n'étaient pas présentes. Ce modèle généralement
prend plus de temps pour compléter le cycle de vie du logiciel car lorsqu'une étape
une fois terminé, il est validé et le développement passe à l'étape suivante.

Page | 2
 Spécification des exigences logicielles

Functional requirements:

Le numéro d'accession, le numéro de rouleau et l'identification de l'enseignant doivent tous

soyez unique car ils forment les clés primaires des tables respectives.
Tous les nouveaux livres doivent d'abord être saisies dans le tableau d'entrée, pour éviter
problèmes plus tard.
Un livre ne doit pas être supprimé du profil de l'étudiant à moins que
elle paie l'amende appropriée ou le même livre.
Lors de l'insertion de valeurs dans la base de données, seules des valeurs valides doivent être
entré.

Exigences en matière de données :

Le système de gestion de bibliothèque devra être en mesure de maintenir

informations sur ses utilisateurs et ses livres.
Il devra stocker des bases de données pour les étudiants, les enseignants et les livres.
La base de données des étudiants stocke des informations sur le numéro de rouleau d'un étudiant,
name, address, course and year.
La base de données des livres stocke des informations sur le titre d'un livre, l'auteur,
publisher, cost, bill number, year of publishing and pages.
La base de données des enseignants stocke des informations sur l'identifiant d'un enseignant, son nom,
département, désignation, adresse et numéro de téléphone.

Exigences logicielles : Le système sur lequel la gestion de la bibliothèque

Le système est installé, il doit avoir Microsoft Windows.

Exigences matérielles : Intel x86 de la vraie famille 15 Modèle 2 Révision

4, 120 Mo de RAM.

Page | 3
 Services fournis à l'utilisateur

Le système de gestion de bibliothèque automatise les fonctions de base de la bibliothèque pour

aider dans les opérations quotidiennes d'une bibliothèque. Il supporte des fonctions telles que
problème, retour, les fonctions très basiques de recherche d'un livre particulier, etc.
Il maintient également des données sur les livres, les enseignants et les dossiers des étudiants.
qui sont nécessaires lors de diverses opérations bibliothéconomiques. Le logiciel vise à
rendre le système convivial et efficace.

Les fonctions que le système de gestion de bibliothèque fournit sont les suivantes :

[Link]ÉRER : Cette opération est effectuée lorsque de nouvelles données doivent être ajoutées.
ajouté au système, par exemple lorsque le département achète un nouveau livre,
L'entrée du livre est insérée dans la base de données des livres. Cette option a
trois choix :
a)Livre : Ce choix permet d'entrer des données sur les nouvelles acquisitions.
des livres dans la base de données des livres. Les données saisies incluent
book’s author, title, publisher, cost and various other fields
fournis sous forme. Les données doivent être précises et doivent être
entré dans le format correct tel qu'indiqué dans les formulaires.
b) Enseignant : Cette option est utilisée pour entrer des données pour un nouvel enseignant
dans la base de données des enseignants. Cette option est choisie lorsqu'un enseignant
rejoins le collège.
c) Étudiant : Cela enregistrera un nouvel enregistrement pour un étudiant dans le registre de l'étudiant.
base de données. Cette option est choisie lorsqu'un étudiant est inscrit dans le
collège.
[Link] : Cette opération efface les enregistrements existants dans les divers
bases de données. Il est utilisé par exemple lorsqu'un membre quitte le collège ou lorsque
le livre est retiré de la bibliothèque. Mais il faut faire attention pendant que
effectuer cette opération et permission obtenue de la tête de
bibliothèque parce que le système pourrait perdre des données importantes.
Il peut être effectué sur toutes les bases de données et les trois choix sont :
a)Livre : Cela introduira une valeur nulle pour le livre dont l'accession
un numéro est saisi dans le champ prévu dans le formulaire respectif.
Cette opération est effectuée lorsqu'un livre est retiré de la bibliothèque.

Page | 4
 b) Enseignant : Cela effacera le dossier d'un enseignant en particulier
dont le numéro d'identification est saisi. Cette option est choisie
quand un enseignant quitte le collège.
c) Étudiant : Cela effacera le dossier de l'étudiant en particulier
dont le dossier doit être supprimé en entrant son numéro de rôle dans
le champ requis. Cette option est choisie lorsqu'un étudiant part
collège.
[Link] À JOUR : Cette fonction met à jour les données dans les différents enregistrements. Cela

l'opération est soutenue par les trois entrées :

a)Livre:Cette fonction ne serait généralement pas requise pour
mettre à jour le statut d'un livre car ces données ne changeraient pas.
b) Enseignant : Cela mettra à jour les données d'un enseignant particulier, dont
les données ont changé comme l'adresse, le numéro de téléphone, etc. en entrant
son numéro d'identification.
c)Étudiant : Cela mettra à jour les données de l'étudiant comme l'adresse,
cours, etc. en saisissant le numéro de dossier de l'étudiant.
[Link] : Cette fonction est utilisée pour rechercher des données particulières à partir de

database. This function can search for data related to all the three
entities:
a)Livre : Pour chercher un livre particulier, pour savoir s'il est
actuellement disponible dans la bibliothèque ou non. Cela peut être fait par
entrer une valeur dans un ou plusieurs champs du formulaire pour effectuer
la recherche par titre ou nom d'auteur.
b) Enseignant : Cela permettra de déterminer l'enseignant particulier qui est actuellement
a le livre pour lequel la recherche est effectuée.
c) Étudiant : Cela permettra de trouver l'étudiant particulier qui possède
le livre particulier.
5. PROBLÈME : Cette opération est utilisée pour émettre un livre à un membre de la
bibliothèque. Pour que cette opération soit réussie, le membre doit répondre à certains
des critères comme elle ne devrait pas avoir émis de livres à sa limite maximale
Auparavant. Tous ces contrôles sont effectués par des logiciels. Si l'opération est
réussi, alors le système stocke automatiquement la date d'émission et le
date limite à laquelle le livre doit être rendu.
a)Étudiant : Lorsqu'un étudiant emprunte un livre, l'entrée du livre est
stocké automatiquement dans la base de données de l'étudiant avec la date d'échéance
de ce livre.
b) Enseignant : Dans le cas où un membre du personnel enseignant prête un livre le
l'entrée est stockée dans la base de données de l'enseignant avec la date d'échéance du
livre.

Page | 5
[Link] : En utilisant cette opération, un membre retourne les articles, qui
elle a emprunté, de la bibliothèque pour le rendre. Si le livre, qui est prêté
n'est pas retourné dans le délai spécifié, le membre se retrouve comme un
défaillant et elle est tenue de payer une amende qui est calculée
automatiquement par le logiciel.
a) Enseignant : Cela supprimera l'entrée correspondante faite dans
base de données des enseignants.
b) Étudiant : Cela supprimera l'entrée correspondante faite dans
base de données des étudiants.
[Link] : Ceci est utilisé pour afficher chaque enregistrement, c'est-à-dire
enregistrement de chaque livre, enseignant et étudiant dans la bibliothèque.
a)Livre : Enregistrement de chaque livre, c'est-à-dire son numéro d'accès,
author name, publisher name, etc.
b) Enseignant : Dossier de chaque enseignant, c'est-à-dire son identifiant, son département,

nombre de livres émis, etc., qui est membre du collège

bibliothèque.
c) Étudiant : Dossier de chaque étudiant, c'est-à-dire son numéro de rouleau,
cours, nombre de livres empruntés, etc., qui est membre de la
bibliothèque universitaire.

[Link]:This takes user out of the application.

Page | 6
Page | 7
Diagrammes de flux de données

Page | 8
Page | 9
Page | 10
 Code source
//**********************************************************
// BIBLIOTHÈQUE DE PROJET
//**********************************************************

//**********************************************************
// FICHIERS D'EN-TÊTE INCLUS
//**********************************************************

#include <iostream.h>
#include <fstream.h>
#include <process.h>
#inclure <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <dos.h>

//**********************************************************
// CETTE CLASSE CONTRÔLE TOUTES LES FONCTIONS DU MENU
//**********************************************************

classe MENU
{
public
void menu_principal(void) ;
void introduction(void) ;
private :
void éditer_menu(void) ;
void modifier_livre(void) ;
void modifier_membre(void);
} ;

//**********************************************************
// CETTE CLASSE CONTIENT DES FONCTIONS LIÉES AUX LIVRES
//**********************************************************

classe LIVRE
{
public
void liste(void) ;
char *nomdelivre(int);
protégé
void ajouter_nouveau_livre(int, char tname[33], char
tauteur[26],flottant,int,int) ;
void mettre_a_jour_exemplaires(int,int,int) ;
void modifier(int,char[],char[],float);
void suppression(void);

Page | 11
 int livre_trouvé(int);
int nom_livre_trouvé(char []) ;
int recordno(int);
int disponible(int);
char *nomd'auteur(int) ;
float prixLivre(int);
int nombre_de_copies(int);
int codeDuLivreDe(char[]) ;
vide afficher(int);
int reccount(void);
void supprimer_rec(int);
privé
int codeLivre, exemplaires ;
char nom[33], auteur[26] ;
flottant prix ;
int disponible ;
} ;

//**********************************************************
// CETTE CLASSE CONTIENT DES FONCTIONS LIÉES AUX MEMBRES
//**********************************************************

classe MEMBRE
{
public
void liste(void) ;
protégé
void ajouter_mémoire(int,int,char [],char [],char[],int,
int,int) ;
void modifier(int,char[],char[],char[]) ;
int membre_trouvé(int) ;
void mettre_a_jour_livre(int,int,int,int,int);
char *nommembre(int);
char *membretelephone(int) ;
char *adresse_membre(int) ;
int recordno(int);
int lastcode(void) ;
int émis(int);
int fine(int);
void afficher(int) ;
void delete_rec(int);
privé
int memcode, bookcode ;
char name[26], phone[10], address[33] ;
int dd, mm, aa ;// DATE DE RETOUR DU LIVRE //
} ;

//**********************************************************
// CECI EST DÉRIVÉ DE LA CLASSE LIVRE & MEMBRE ET CONTIENT
// FONCTIONS POUR TRAVAILLER (PROBLÈME, RETOUR, ETC).
//**********************************************************

classe TRAVAIL : public LIVRE, public MEMBRE

{
public

Page | 12
 void emettreLivre(void);
void rendreLivre(void) ;
void ajouter_livre(void);
void ajouter_membre(void);
void modifier_livre(void);
void modifier_membre(void) ;
void supprimer_livre(void) ;
void supprimer_membre(void);
} ;

//**********************************************************
// CETTE CLASSE CONTIENT DES FONCTIONS LIÉES À LA DATE ET À L'AMENDE
//**********************************************************

classe DATE
{
public
void étendre_date(int,int,int,int);
int diff(int,int,int,int,int,int);
int jour, mois, an ;
} ;

//**********************************************************
// FONCTION POUR PROLONGER UNE DATE DONNÉE DE 15 JOURS
//**********************************************************

void DATE :: étendre_date(int d1, int m1, int y1, int jours)
{
statique int mois[] = {31,29,31,30,31,30,31,31,30,31,30,31} ;
pour (int i=1; i<=jours; i++)
{
d1++ ;
si ((d1 > month[m1-1]) || (y1%4 != 0 && m1 == 2 && d1 > 28))
{
d1 = 1 ;
m1++ ;
}
si (m1 > 12)
{
m1 = 1 ;
y1++ ;
}
}
day = d1 ;
mon = m1 ;
year = y1 ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LA DIFFÉRENCE ENTRE DEUX DONNÉES DONNÉES
// DATES
//**********************************************************

Page | 13
int DATE :: diff(int j1, int m1, int a1, int j2, int m2, int a2)
{
int jours = 0 ;
si ((y2<y1) || (y2==y1 && m2<m1) || (y2==y1 && m2==m1 && d2<d1))
retourner les jours ;
statique int mois[] = {31,29,31,30,31,30,31,31,30,31,30,31} ;
tant que (d1 != d2 || m1 != m2 || y1 != y2)
{
jours++ ;
d1++ ;
si ((d1 > mois[m1-1]) || (y1%4 != 0 && m1 == 2 && d1 > 28))
{
d1 = 1 ;
m1++ ;
}
si (m1 > 12)
{
m1 = 1 ;
y1++ ;
}
}
retourner jours ;
}

//**********************************************************
// FONCTION POUR AFFICHER LE MENU PRINCIPAL & CONTRÔLER TOUTES LES FONCTIONS
// DANS LE MENU PRINCIPAL.
//**********************************************************

void MENU :: menu_principal(void)

{
char ch ;
tandis que (1)
{
effacer() ;
gotoxy(29,6) ;
cout << "B O O K L I B R A R Y" ;
gotoxy(29,7) ;
cout << "~~~~~~~~~~~~~~~~~~~~~~" ;
gotoxy(30,10) ;
cout << "1. INTRODUCTION" ;
gotoxy(30,11) ;
cout << "2. AJOUTER UN NOUVEAU LIVRE" ;
gotoxy(30,12) ;
cout << "3. AJOUTER UN NOUVEAU MEMBRE" ;
gotoxy(30,13) ;
cout <<"4. EMPRUNTER UN LIVRE" ;
gotoxy(30,14) ;
cout << "5. RETOURNER LE LIVRE" ;
gotoxy(30,15) ;
cout <<"6. LISTE DES LIVRES" ;
gotoxy(30,16) ;
cout << "7. LISTE DES MEMBRES" ;
gotoxy(30,17) ;
cout << "8. ÉDIT" ;
gotoxy(30,18) ;

Page | 14
 cout << "0. QUITTER" ;
gotoxy(30,20) ;
cout << "Entrez votre choix : " ;
ch = getche() ;
si (ch == 27)
pause ;
sinon
si (ch == '1')
introduction() ;
sinon
si (ch == '2')
{
TRAVAILLER W ;
W.ajouter_livre() ;
}
sinon
si (ch == '3')
{
TRAVAILLER W ;
W.ajouter_membre() ;
}
autre
si (ch == '4')
{
TRAVAILLEMENT W ;
[Link]() ;
}
sinon
si (ch == '5')
{
TRAVAILLER
[Link]() ;
}
sinon
si (ch == '6')
{
BOOK B ;
[Link]() ;
}
sinon
si (ch == '7')
{
MEMBRE M ;
[Link]() ;
}
sinon
si (ch == '8')
modifier_menu() ;
sinon
si (ch == '0')
pause ;
}
}

//**********************************************************
// FONCTION POUR AFFICHER LE MENU D'EDITION

Page | 15
//**********************************************************

void MENU :: editer_menu(void)

{
char ch ;
tandis que (1)
{
clrscr() ;
gotoxy(32,9) ;
cout <<"E D I T M E N U";
gotoxy(32,10) ;
cout << "~~~~~~~~~~~~~~~~" ;
gotoxy(34,13) ;
cout << "1. LIVRES";
gotoxy(34,14) ;
cout << "2. MEMBRES" ;
gotoxy(34,15) ;
cout <<"0. SORTIR" ;
gotoxy(31,17) ;
cout << "Entrez votre choix : " ;
ch = getche() ;
si (ch == 27)
pause ;
sinon
si (ch =='1')
éditer_le_livre() ;
sinon
si (ch == '2')
éditer_membre() ;
sinon
if (ch == '0')
pause;
}
}

//**********************************************************
// FONCTION POUR AFFICHER LE MENU D'ÉDITION POUR LE LIVRE & LE CONTRÔLE
// TOUTES LES FONCTIONS DU MENU ÉDITER.
//**********************************************************

void MENU :: modifier_livre(void)

{
char ch ;
tandis que (1)
{
clrscr() ;
gotoxy(31,9) ;
cout <<"E D I T E R L I V R E S";
gotoxy(31,10) ;
cout << "~~~~~~~~~~~~~~~~~~" ;
gotoxy(34,13) ;
cout << "1. MODIFIER" ;
gotoxy(34,14) ;
cout << "2. SUPPRIMER" ;
gotoxy(34,15) ;
cout <<"0. QUITTER" ;

Page | 16
 gotoxy(31,17) ;
cout << "Entrez votre choix : " ;
ch = getche() ;
si (ch == 27)
pause ;
sinon
si (ch == '1')
{
TRAVAILLER W ;
W.modifier_livre();
}
sinon
si (ch == '2')
{
TRAVAILLER W ;
W.supprimer_livre() ;
}
sinon
si (ch == '0')
pause ;
}
}

//**********************************************************
// FONCTION POUR AFFICHER LE MENU D'ÉDITION POUR LES MEMBRES ET LE CONTRÔLE
// TOUTES LES FONCTIONS DU MENU ÉDITER.
//**********************************************************

vid MENU :: modifier_membre(void)

{
char ch ;
tandis que (1)
{
clrscr() ;
gotoxy(29,9) ;
cout <<"E D I T E R M E M B R E S";
gotoxy(29,10) ;
cout << "~~~~~~~~~~~~~~~~~~~~~~" ;
gotoxy(34,13) ;
cout << "1. MODIFIER" ;
gotoxy(34,14) ;
cout << "2. SUPPRIMER" ;
gotoxy(34,15) ;
cout << "0. SORTIR" ;
gotoxy(29,17) ;
cout << "Entrez votre choix : " ;
ch = getche() ;
si (ch == 27)
pause ;
sinon
si (ch == '1')
{
TRAVAIL W ;
W.modifier_membre() ;
}
sinon

Page | 17
 si (ch == '2')
{
TRAVAIL EN C;
W.supprimer_membre() ;
}
sinon
si (ch == '0')
pause ;
}
}

//**********************************************************
// FONCTION POUR AFFICHER L'INTRODUCTION DU PROJET.
//**********************************************************

void MENU :: introduction(void)

{
effacer() ;
gotoxy(31,5) ;
cout << "Bienvenue au Projet" ;
textcolor(NOIR+CLIGNOTER) ; textbackground(BLANC) ;
gotoxy(33,7) ;
cprintf(" BIBLIOTHÈQUE DE LIVRES ") ;
textcolor(LIGHTGRAY) ; textbackground(BLACK) ;
gotoxy(15,10) ;
cout << "Ce projet dispose de la possibilité de maintenir des enregistrements" ;
gotoxy(15,11) ;
de LIVRES et de MEMBRES.
gotoxy(15,13) ;
Ce projet peut contenir plus de 10 000 livres
gotoxy(15,14) ;
cout << "enregistrements." ;
gotoxy(15,16) ;
Un membre peut emprunter un livre à la fois. S'il/elle
gotoxy(15,17) ;
cout << "ne retourne pas le livre jusqu'à 15 jours il/elle doit" ;
gotoxy(15,18) ;
payer une amende de 2 Rs par jour.
textcolor(LIGHTGRAY+BLINK) ;
gotoxy(27,24) ;
Appuyez sur une touche pour continuer
textcolor(LIGHTGRAY) ;
getch() ;
}

//**********************************************************
// CETTE FONCTION RENVOIE 0 SI LE CODE DU LIVRE DONNÉ N'EST PAS TROUVÉ
//**********************************************************

int LIVRE :: livre_trouvé(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg);
int trouvé=0 ;

Page | 18
 tant que ([Link]((char *)this,sizeof(BOOK)))
{
si (codeLivre == codeT)
{
found = 1 ;
pause ;
}
}
[Link]() ;
retourner trouvé ;
}

//**********************************************************
// CETTE FONCTION RENVOIE 0 SI LE NOM DU LIVRE DONNÉ N'EST PAS TROUVÉ
//**********************************************************

int LIVRE :: nom_de_livre_trouvé(char code_t1[33])

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg) ;
int trouvé=0 ;
tant que ([Link]((char *)this,sizeof(BOOK)))
{
si (!strcmpi(nom,t1code))
{
found = 1 ;
pause ;
}
}
[Link]() ;
Retour trouvé ;
}

//**********************************************************
// CETTE FONCTION RETOURNE LE NUMÉRO D'ENREGISTREMENT POUR LE CODE DU LIVRE
//**********************************************************

int LIVRE :: enregno(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg) ;
int compte=0 ;
while ([Link]((char *)this,sizeof(BOOK)))
{
compter++ ;
si (codeLivre == codeT)
pause ;
}
[Link]() ;
retourner le compte ;
}

Page | 19
//**********************************************************
// Cette fonction retourne les exemplaires disponibles pour le donné
// CODE DU LIVRE.
//**********************************************************

int LIVRE :: disponible(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0, ios::beg);
int tavail=0 ;
while ([Link]((char *)this,sizeof(BOOK)))
{
si (codeDuLivre == codeT)
{
tavail = avail ;
pause ;
}
}
[Link]() ;
retourner tavail ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE NOMBRE DE COPIES POUR LE DONNÉ
// CODE DU LIVRE.
//**********************************************************

int LIVRE :: no_de_copies(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg);
int tcopies=0 ;
tant que ([Link]((char *)this,sizeof(BOOK)))
{
si (lecodebook == lecode)
{
tcopies = copies ;
pause ;
}
}
[Link]() ;
retourner tcopies ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE NOM DU LIVRE DU LIVRE DONNÉ
// CODE.
//**********************************************************

char *LIVRE :: nomDuLivre(int codeT)

{
fstream fichier ;
[Link]("[Link]", ios::in);

Page | 20
 [Link](0,ios::beg) ;
char tname[33] ;
tandis que ([Link]((char *)this,sizeof(LIVRE)))
{
si (codeLivre == codeT)
{
strcpy(tname, nom) ;
pause ;
}
}
[Link]() ;
retourner tname ;
}

//**********************************************************
// CETTE FONCTION RETOURNE LE NOM DE L'AUTEUR DU LIVRE DONNÉ
// CODE.
//**********************************************************

char *LIVRE :: nomAuteur(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
char tauthor[26] ;
tandis que ([Link]((char *)this,sizeof(BOOK)))
{
si (codeLivre == codeT)
{
strcpy(tauteur,auteur) ;
faire une pause ;
}
}
[Link]() ;
retourne tauteur ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE PRIX DU LIVRE DU LIVRE DONNÉ
// CODE.
//**********************************************************

float LIVRE :: prixlivre(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg);
float tprice=0.0 ;
tant que ([Link]((char *)this,sizeof(LIVRE)))
{
si (codeLivre == codeT)
{
tprice = price ;
pause ;
}

Page | 21
 }
[Link]() ;
return tprice ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE CODE DU LIVRE DU LIVRE DONNÉ
// NOM.
//**********************************************************

int LIVRE :: codeDuLivre(char t1code[33])

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg);
int tcode=0 ;
tandis que ([Link]((char *)this,sizeof(BOOK)))
{
si (!strcmpi(name,t1code))
{
tcode = codeLivre ;
pause ;
}
}
[Link]() ;
retourner tcode ;
}

//**********************************************************
// THIS FUNCTION RETURNS THE NO. OF THE RECORDS IN THE BOOK
// FICHIER.
//**********************************************************

int LIVRE :: nombreDeRec(void)

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg);
int count = 0 ;
pendant que ([Link]((char *)this,sizeof(BOOK)))
count++ ;
[Link]() ;
returner le compte ;
}

//**********************************************************
// CETTE FONCTION SUPPRIME L'ENREGISTREMENT DU CODE DE LIVRE DONNÉ.
//**********************************************************

void LIVRE :: supprimer_enregistrement(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in);
fstream temp ;

Page | 22
 [Link]("[Link]", ios::out) ;
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(BOOK)) ;
si ( [Link]() )
pause ;
si ( bookcode != tcode )
[Link]((char *)this,sizeof(BOOK)) ;
}
[Link]() ;
[Link]() ;
[Link]("[Link]", ios::out) ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(BOOK)) ;
si ( [Link]() )
pause ;
[Link]((char *)this,sizeof(BOOK)) ;
}
fermer le fichier() ;
[Link]() ;
}

//**********************************************************
// CETTE FONCTION AJOUTE L'ENREGISTREMENT DANS LE FICHIER DU LIVRE
//**********************************************************

void LIVRE :: ajouter_nouveau_livre(int tcode,char tnom[33],char tauteur[26],

float tprice,int tcopies,int tavail)
{
fstream fichier ;
[Link]("[Link]", ios::app);
bookcode = tcode ;
strcpy(nom,tnom) ;
strcpy(auteur,tauteur) ;
price = tprice ;
copies = tcopies ;
avail = tavail ;
[Link]((char *)this,sizeof(BOOK)) ;
[Link]() ;
}

//**********************************************************
// CETTE FONCTION MET À JOUR L'ENREGISTREMENT DANS LE FICHIER DE LIVRE POUR LE
// CODE DE LIVRE DONNE
//**********************************************************

void LIVRE :: mettre_a_jour_exemplaires(int tcode,int tcopies,int tavail)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
fstream temp ;

Page | 23
 [Link]("[Link]", ios::out);
[Link](0, ios::beg);
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(BOOK)) ;
si ( [Link]() )
pause ;
si ( codeLivre == codeT )
{
copies = tcopies ;
avail = tavail ;
[Link]((char *)this,sizeof(BOOK)) ;
}
sinon
[Link]((char *)this,sizeof(BOOK)) ;
}
[Link]() ;
[Link]() ;
[Link]("[Link]", ios::sortie);
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(BOOK)) ;
si ( [Link]() )
pause ;
[Link]((char *)this,sizeof(BOOK)) ;
}
[Link]() ;
[Link]() ;
}

//**********************************************************
// THIS FUNCTION MODIFY THE RECORD IN THE BOOK FILE FOR THE
// CODE DE LIVRE DONNÉ
//**********************************************************

void LIVRE :: modifier(int tcode, char tname[33], char tauthor[26], float

tprice)
{
fstream fichier ;
[Link]("[Link]", ios::in);
fstream temp ;
[Link]("[Link]", ios::out) ;
[Link](0, ios::beg);
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(BOOK)) ;
si ( [Link]() )
pause ;
si ( codeLivre == codeT )
{
strcpy(name,tname) ;
strcpy(auteur,tauteur) ;
price = tprice ;
[Link]((char *)this,sizeof(BOOK)) ;

Page | 24
 }
sinon
[Link]((char *)this,sizeof(BOOK)) ;
}
[Link]() ;
[Link]() ;
[Link]("[Link]", ios::out) ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
while ( ![Link]() )
{
[Link]((char *)this,sizeof(BOOK));
si ( [Link]() )
pause ;
[Link]((char *)this,sizeof(BOOK)) ;
}
[Link]() ;
[Link]() ;
}

//**********************************************************
// CETTE FONCTION AFFICHE L'ENREGISTREMENT DU FICHIER DE LIVRE
// POUR LE CODE DU LIVRE DONNÉ
//**********************************************************

void LIVRE :: afficher(int tcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
tant que ([Link]((char *)this,sizeof(BOOK)))
{
si (codeLivre == codeT)
{
gotoxy(5,5) ;
cout << "Code du livre : " << bookcode ;
gotoxy(5,7) ;
cout << "Nom du livre : " << name ;
gotoxy(5,8) ;
cout << "Nom de l'auteur : " << auteur ;
gotoxy(5,9) ;
cout << "Prix : Rs." << prix ;
gotoxy(5,10) ;
cout << "Copies : " << prix ;
gotoxy(5,11) ;
cout << "Disponible : " << avail ;
pause ;
}
}
[Link]() ;
}

//**********************************************************
// CETTE FONCTION AFFICHE LA LISTE DES LIVRES.
//**********************************************************

Page | 25
void LIVRE :: lister(void)
{
clrscr() ;
int ligne = 6, trouvé = 0, drapeau = 0;
char ch ;
gotoxy(33,2) ;
LISTE DES LIVRES
gotoxy(32,3) ;
cout << "~~~~~~~~~~~~~~~" ;
gotoxy(1,4) ;
cout << "NOM DU LIVRE DE CODE AUTEUR
PRIX EXEMPLES
gotoxy(1,5) ;
coût
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~" ;
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg) ;
tandis que ([Link]((char *)this,sizeof(BOOK)))
{
flag = 0 ;
retard(20) ;
found = 1 ;
gotoxy(2,ligne) ;
cout <<codeLivre ;
gotoxy(7,ligne) ;
cout << nom ;
gotoxy(40, ligne) ;
cout <<auteur ;
gotoxy(66,row) ;
cout <<prix ;
gotoxy(73,row) ;
cout <<copies ;
fondTexte(Blanc) ; couleurTexte(Noir) ;
gotoxy(40,row+1) ;
cprintf("ÉTAT : ") ;
textcolor(NOIR+CLIGNOTANT) ;
printf("%d copies disponibles", avail) ;
fondtexte(NOIR) ; couleurtexte(GRISCLAIR) ;
si ( ligne == 22 )
{
flag = 1 ;
row = 6 ;
gotoxy(1,25) ;
appuyez sur une touche pour continuer ou appuyez sur <ESC> pour
sortie
ch = getch() ;
si (ch == 27)
pause ;
effacer() ;
gotoxy(33,2) ;
cout << "LISTE DES LIVRES" ;
gotoxy(32,3) ;
cout << "~~~~~~~~~~~~~~~" ;
gotoxy(1,4) ;

Page | 26
 cout <<"NOM DU LIVRE DE CODE AUTEUR "
PRIX COPIES
gotoxy(1,5) ;
coût
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~" ;
}
sinon
ligne = ligne + 2 ;
}
si (!trouvé)
{
gotoxy(5,10) ;
cout <<" Enregistrements non trouvés" ;
}
si (!flag)
{
gotoxy(1,25) ;
Appuyez sur une touche pour continuer...
getche() ;
}
[Link]();
}

//**********************************************************
// CETTE FONCTION RETOURNE 0 SI LE CODE DE MEMBER DONNÉ N'EST PAS TROUVÉ
//**********************************************************

int MEMBRE :: membre_trouvé(int mcode)

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg);
int trouvé=0 ;
tandis que ([Link]((char *)this,sizeof(MEMBER)))
{
si (memcode == mcode)
{
found = 1 ;
pause ;
}
}
[Link]() ;
retourner trouvé ;
}

//**********************************************************
// CETTE FONCTION RETOURNE 0 SI LE MEMBRE N'A PAS ÉMIS AUCUN
// LIVRE.
//**********************************************************

int MEMBRE :: émis(int mcode)

{
fstream file ;
[Link]("[Link]", ios::in);

Page | 27
 [Link](0,ios::beg);
int missue=0 ;
tant que ([Link]((char *)this,sizeof(MEMBER)))
{
si (memcode == mcode)
{
missue = bookcode ;
pause ;
}
}
[Link]() ;
retourner le problème ;
}

//**********************************************************
// CETTE FONCTION CALCULE ET RENVOIE L'AMENDE POUR LE DONNÉ
// CODE MEMBRE.
//**********************************************************

int MEMBRE :: amende(int mcode)

{
DATE D ;
int j1, m1, a1 ;
struct date d;
getdate(&d);
d1 = d.jour_da ;
m1 = d.da_mon ;
y1 = d.da_year ;
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
int jours, t_amende ;
tant que ([Link]((char *)this,sizeof(MEMBER)))
{
si (memcode == mcode)
{
days = [Link](dd,mm,yy,d1,m1,y1) ;
t_fine = days * 2 ;
pause ;
}
}
[Link]() ;
retourner t_fine ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE DERNIER CODE DU FICHIER MEMBRE.
//**********************************************************

int Membre :: dernierCode(void)

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg);
int mcode=0 ;

Page | 28
 tant que ([Link]((char *)this,sizeof(MEMBER)))
mcode = memcode ;
[Link]() ;
retourne mcode ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE NOM DU MEMBRE DU MEMBRE DONNÉ
// CODE.
//**********************************************************

char *MEMBRE :: nomMembre(int mcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg);
char mname[26] ;
tandis que ([Link]((char *)this,sizeof(MEMBER)))
{
si (memcode == mcode)
{
strcpy(mname, name);
pause ;
}
}
[Link]() ;
retourner mname ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE TÉLÉPHONE DU MEMBRE DONNÉ
// CODE.
//**********************************************************

char *MEMBER :: membretelephone(int mcode)

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg) ;
char mphone[10] ;
tant que ([Link]((char *)this,sizeof(MEMBER)))
{
si (memcode == mcode)
{
strcpy(mphone, phone) ;
pause ;
}
}
[Link]() ;
retourner mphone ;
}

//**********************************************************
// CETTE FONCTION RETOURNE L'ADRESSE DU MEMBRE DONNÉ

Page | 29
// CODE.
//**********************************************************

char *MEMBRE :: adresseMembre(int codeMembre)

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0, ios::beg);
char madresse[33] ;
tandis que ([Link]((char *)this,sizeof(MEMBER)))
{
si (memcode == mcode)
{
strcpy(madresse,adresse) ;
pause ;
}
}
[Link]() ;
retourner madresse ;
}

//**********************************************************
// CETTE FONCTION RENVOIE LE NUMÉRO DE DOSSIER DU MEMBRE DONNÉ
// CODE.
//**********************************************************

int MEMBRE :: recordno(int mcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg);
int count=0 ;
tant que ([Link]((char *)this,sizeof(MEMBER)))
{
compter++ ;
si (memcode == mcode)
pause ;
}
[Link]() ;
retourner le compte ;
}

//**********************************************************
// CETTE FONCTION SUPPRIME L'ENREGISTREMENT POUR LE CODE DE MEMBRE DONNÉ.
//**********************************************************

void MEMBER :: supprimer_enregistrement(int mcode)

{
fstream fichier ;
[Link]("[Link]", ios::in) ;
fstream temp ;
[Link]("[Link]", ios::out);
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{

Page | 30
 [Link]((char *)this,sizeof(MEMBER)) ;
si ( [Link]() )
pause ;
si ( memcode != mcode )
[Link]((char *)this,sizeof(MEMBER)) ;
}
fermer le fichier() ;
[Link]() ;
[Link]("[Link]", ios::sortie);
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(MEMBER)) ;
si ( [Link]() )
pause ;
[Link]((char *)this,sizeof(MEMBER)) ;
}
[Link]() ;
[Link]() ;
}

//**********************************************************
// CETTE FONCTION MET À JOUR L'ENREGISTREMENT POUR LE CODE DE MEMBRE DONNÉ.
//**********************************************************

void Membre :: mettre_a_jour_livre(int mcode,int tcode,int d1,int m1,int y1)

{
fstream fichier ;
[Link]("[Link]", ios::in);
fstream temp ;
[Link]("[Link]", ios::out);
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(MEMBER)) ;
si ( [Link]() )
pause ;
si ( memcode == mcode )
{
bookcode = tcode ;
dd = d1 ;
mm = m1 ;
yy = y1 ;
[Link]((char *)this,sizeof(MEMBER)) ;
}
sinon
[Link]((char *)this,sizeof(MEMBER)) ;
}
[Link]() ;
[Link]() ;
[Link]("[Link]", ios::out);
[Link]("[Link]", ios::in);
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{

Page | 31
 [Link]((char *)this,sizeof(MEMBER)) ;
si ( [Link]() )
pause ;
[Link]((char *)this,sizeof(MEMBER)) ;
}
[Link]() ;
[Link]() ;
}

//**********************************************************
// THIS FUNCTION MODIFY RECORD FOR THE GIVEN MEMBER CODE.
//**********************************************************

void Membre :: modifier(int mcode, char mnom[26], char mtelephone[10], char

maddress[33])
{
fstream fichier ;
[Link]("[Link]", ios::in) ;
fstream temp ;
[Link]("[Link]", ios::out) ;
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(MEMBER));
si ( [Link]() )
pause ;
si ( memcode == mcode )
{
strcpy(name,mname);
strcpy(téléphone,mportable) ;
strcpy(adresse,madresse) ;
[Link]((char *)this,sizeof(MEMBER)) ;
}
sinon
[Link]((char *)this,sizeof(MEMBER));
}
[Link]() ;
[Link]() ;
[Link]("[Link]", ios::out) ;
[Link]("[Link]", ios::in) ;
[Link](0,ios::beg) ;
tant que ( ![Link]() )
{
[Link]((char *)this,sizeof(MEMBER)) ;
si ( [Link]() )
pause ;
[Link]((char *)this,sizeof(MEMBER)) ;
}
[Link]() ;
[Link]() ;
}

//**********************************************************
// CETTE FONCTION AJOUTE UN ENREGISTREMENT DANS LE FICHIER POUR LE DONNÉ
// CODE MEMBRE.

Page | 32
//**********************************************************

void MEMBRE :: ajouter_mem(int mcode, int bcode, char mnom[26], char

madresse[33],char mtelephone[10],int d1,int m1,int y1)
{
fstream fichier ;
[Link]("[Link]", ios::app);
memcode = mcode ;
bookcode = bcode ;
strcpy(nom,mnom) ;
strcpy(adresse,madresse) ;
strcpy(téléphone,mportable) ;
dd = d1 ;
mm = m1 ;
yy = y1 ;
[Link]((char *)this,sizeof(MEMBER)) ;
[Link]() ;
}

//**********************************************************
// CETTE FONCTION AFFICHE L'ENREGISTREMENT POUR LE MEMBRE DONNÉ
// CODE.
//**********************************************************

void MEMBRE :: afficher(int mcode)

{
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg);
tant que ([Link]((char *)this,sizeof(MEMBER)))
{
si (memcode == mcode)
{
gotoxy(5,3) ;
cout << "Code Membre # " << mcode ;
gotoxy(5,4) ;
cout << "~~~~~~~~~~~~~~~~~" ;
gotoxy(5,6) ;
cout << "Nom : " << nom ;
gotoxy(5,7) ;
cout << "Téléphone : " << phone ;
gotoxy(5,8) ;
cout << "Adresse : " << adresse ;
pause ;
}
}
[Link]() ;
}

//**********************************************************
// CETTE FONCTION AFFICHE LA LISTE DES MEMBRES
//**********************************************************

vide Membre :: liste(vide)

{

Page | 33
 effacer() ;
LIVRE B ;
int row = 6 , found=0, flag=0 ;
char ch ;
gotoxy(32,2) ;
cout <<"LISTE DES MEMBRES" ;
gotoxy(31,3) ;
cout << "~~~~~~~~~~~~~~~~~" ;
gotoxy(1,4) ;
cout <<"CODE LIVRE CODE NOM TÉLÉPHONE" ;
gotoxy(1,5) ;
coût
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~" ;
fstream fichier ;
[Link]("[Link]", ios::in);
[Link](0,ios::beg);
tant que ([Link]((char *)this,sizeof(MEMBER)))
{
drapeau = 0 ;
retard(20) ;
found = 1 ;
gotoxy(2,ligne) ;
cout <<memcode ;
gotoxy(10,ligne) ;
cout <<codeLivre ;
gotoxy(19,ligne) ;
cout <<nom ;
gotoxy(48,ligne) ;
cout <<téléphone ;
textearrière-plan(BLANC) ; textecouleur(NOIR) ;
gotoxy(7,row+1) ;
si (codeLivres == 0)
cprintf("NOM DU LIVRE : (Non Émis)");
sinon
{
printf("NOM DU LIVRE : %s", [Link](codeLivre)) ;
gotoxy(42,row+1) ;
printf("Date de retour : ") ;
textcolor(NOIR+CLIGNOTANT) ;
cprintf("%d/%d/%d",dd,mm,yy) ;
}
fondtexte(NOIR) ; couleuretexte(GRIS CLAIR) ;
si ( ligne == 22 )
{
flag = 1 ;
row = 6 ;
gotoxy(1,25) ;
Appuyez sur n'importe quelle touche pour continuer ou appuyez sur <ESC> pour
sortie
ch = getch() ;
si (ch == 27)
pause ;
clrscr() ;
gotoxy(32,2) ;
cout << "LISTE DES MEMBRES" ;
gotoxy(31,3) ;

Page | 34
 cout <<"~~~~~~~~~~~~~~~~~" ;
gotoxy(1,4) ;
cout << "CODE LIVRE CODE NOM "
PHONE" ;
gotoxy(1,5) ;
coût
<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~" ;
}
sinon
ligne = ligne + 2 ;
}
si (!trouvé)
{
gotoxy(5,10) ;
Enregistrements non trouvés
}
si (!drapeau)
{
gotoxy(1,25) ;
Appuyez sur une touche pour continuer...
getche() ;
}
[Link] ();
}

//**********************************************************
// CETTE FONCTION FOURNIT DES DONNÉES POUR AJOUTER UN ENREGISTREMENT DANS LE FICHIER DE LIVRE.
//**********************************************************

void TRAVAIL :: ajouter_livre(void)

{
si (!reccount()) // FONCTION Membre DE LIVRE
{
ajouter_nouveau_livre(0,"null","null",0.0,0,0) ;
LIVRE::supprimer_rec(0) ;
}
char ch ;
int tcode, tcopies, tavail ;
char tname[33], tauthor[26] ;
float tprice=0.0 ;
faire
{
int trouvé=0, valide=0 ;
int tc ;
float t2=0.0 ;
char t[10], t1[10] ;
clrscr() ;
gotoxy(29,3) ;
cout << "ADDITION DES LIVRES" ;
gotoxy(29,4) ;
cout <<"~~~~~~~~~~~~~~~~~~~~~" ;
gotoxy(72,1) ;
<0>=Sortie
gotoxy(5,25) ;
cout << "Entrez le numéro de code du livre" ;

Page | 35
gotoxy(5,5) ;
cout << "Code n° " ;
gets(t) ;
tc = atoi(t) ;
tcode = tc ;
si (tcode == 0)
retourner ;
si (livre_trouvé(tcode))
{
found = 1 ;
gotoxy(19,8) ;
cout <<nomDuLivre(tcode) ;
gotoxy(19,9) ;
cout << nomAuteur(tcode);
gotoxy(22,10) ;
cout << bookprice(tcode) ;
}
gotoxy(5,8) ;
cout <<"Nom du livre : " ;
gotoxy(5,9) ;
cout << "Nom de l'auteur : " ;
gotoxy(5,10) ;
cout <<"Prix : Rs." ;
gotoxy(5,12) ;
cout <<"Copies : " ;
valid = 0 ;
tant que (!valide && !trouvé)
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le nom du livre" ;
gotoxy(19,8) ; clreol() ;
gets(tname) ;
strupr(tname) ;
si (tname[0] == '0')
retourner ;
si (strlen(tname) < 1 || strlen(tname) > 32)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
Entrez correctement (Plage : 1..32)
getch() ;
}
}
valid = 0 ;
tant que (!valide && !trouvé)
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le nom de l'auteur du livre" ;
gotoxy(19,9) ; clreol() ;
get(tauthor);
strupr(tauthor) ;
si (tauteur[0] == '0')
retourner ;
si (strlen(tauthor) < 1 || strlen(tauthor) > 25)
{

Page | 36
 valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement (Plage : 1..25)" ;
getch();
}
}
valid = 0 ;
tandis que (!valide && !trouvé)
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le prix du livre" ;
gotoxy(22,10) ; clreol() ;
gets(t1) ;
t2 = atof(t1) ;
tprice = t2 ;
si (t1[0] == '0')
retourner ;
si (tprix < 1 || tprix > 9999)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement" ;
getch() ;
}
}
valid = 0 ;
tant que (!valide)
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le nombre d'exemplaires du livre à ajouter" ;
gotoxy(19,12) ; clreol() ;
obtient(t) ;
tc = atoi(t) ;
tcopies = tc ;
si (t[0] == '0')
retourner ;
if (tcopies < 1 || tcopies > 50)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement" ;
getch() ;
}
}
tavail = available(tcode) + tcopies ;
tcopies = no_of_copies(tcode) + tcopies ;
gotoxy(5,25) ; clreol() ;
faire
{
gotoxy(5,15) ; clreol() ;
Souhaitez-vous enregistrer (o/n) :
ch = getche() ;
ch = toupper(ch) ;
}tandis que (ch != 'Y' && ch != 'N') ;

Page | 37
 si (ch == 'Y')
{
si (trouvé)
mettre_a_jour_copies(tcode, tcopies, tavail) ;
sinon

ajouter_nouveau_livre(codet,nomt,auteur,prix,copies,disponibilité);
}
faire
{
gotoxy(5,17) ; clreol() ;
cout << "Voulez-vous ajouter plus (o/n) : ";
ch = getche() ;
ch = toupper(ch) ;
}tant que (ch != 'Y' && ch != 'N') ;
}tant que (ch == 'Y') ;
}

//**********************************************************
// CETTE FONCTION FOURNIT DES DONNÉES POUR AJOUTER UN ENREGISTREMENT DANS LE FICHIER DES MEMBRES
//**********************************************************

void TRAVAIL :: ajouter_membre(void)

{
char ch ;
int mcode, bcode ;
char mname[26], mphone[10], maddress[33] ;
int d1, m1, y1 ;
mcode = derniercode() ;
si (mcode == 0)
{
add_mem(mcode,0,"nul","nul","nul",0,0,0) ;
MEMBRE::supprimer_enr(mcode) ;
}
mcode++ ;
faire
{
int valide=0 ;
effacer() ;
gotoxy(28,3) ;
cout << "ADDITION DES MEMBRES" ;
gotoxy(28,4) ;
cout <<"~~~~~~~~~~~~~~~~~~~~~~~" ;
gotoxy(72,1) ;
cout <<"<0>=Sortie" ;
gotoxy(5,7) ;
cout << "Code Membre # " << mcode ;
gotoxy(5,8) ;
cout <<"~~~~~~~~~~~~~~~~~" ;
gotoxy(5,10) ;
cout << "Nom : " ;
gotoxy(5,12) ;
cout << "Téléphone : " ;
gotoxy(5,14) ;
cout << "Adresse : " ;

Page | 38
 faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le nom du nouveau membre";
gotoxy(15,10) ; clreol() ;
gets(mname) ;
strupr(mname) ;
si (mname[0] == '0')
retourner ;
si (strlen(mname) < 1 || strlen(mname) > 25)
{
valide = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement (Plage : 1..25)" ;
getch() ;
}
}tant que (!valide) ;
faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
Entrez le numéro de téléphone du membre ou appuyez sur <ENTRER>
pour aucun
gotoxy(15,12) ; clreol() ;
gets(mphone) ;
si (mphone[0] == '0')
retourner ;
si ((strlen(mphone) < 7 && strlen(mphone) > 0) ||
(strlen(mphone) > 9))
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement";
getch() ;
}
}tandis que (!valide) ;
si (strlen(mphone) == 0)
strcpy(mphone,"-") ;
faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez l'adresse du nouveau membre" ;
gotoxy(15,14) ; clreol() ;
obtient(madresse) ;
strupr(madresse) ;
si (maddress[0] == '0')
retour ;
si (strlen(maddress) < 1 || strlen(maddress) > 32)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<"\7Entrez correctement (Plage : 1..32)" ;
getch() ;
}
}pendant (!valide) ;

Page | 39
 gotoxy(5,25) ; clreol() ;
faire
{
gotoxy(5,17) ; clreol() ;
cout <<"Voulez-vous enregistrer (o/n) : ";
ch = getche() ;
ch = toupper(ch) ;
si (ch == '0')
retourner ;
}tant que (ch != 'Y' && ch != 'N') ;
si (ch == 'Y')
{
bcode = 0 ;
d1 = 0 ;
m1 = 0 ;
y1 = 0 ;
ajouter_mem(mcode,bcode,mname,maddress,mphone,d1,m1,y1);
mcode++ ;
}
faire
{
gotoxy(5,19) ; clreol() ;
cout << "Voulez-vous en ajouter plus (o/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
si (ch == '0')
retourner ;
}tant que (ch != 'Y' && ch != 'N') ;
}Tant que (ch == 'Y') ;
}

//**********************************************************
// CETTE FONCTION EMET LE LIVRE
//**********************************************************

void TRAVAILLER :: emettrelivre(void)

{
LIVRE B
MEMBRE M ;
DATE D ;
char t1code[33], ch ;
int t2code=0, tcode=0, mcode=0 ;
int valide ;
int d1, m1, y1 ;
struct date d;
obtenir_date(&d);
d1 = d.jour_da ;
m1 = d.da_mon ;
y1 = d.da_year ;
faire
{
valid = 1 ;
tant que (1)
{
clrscr() ;
gotoxy(5,2) ;

Page | 40
 cout << "Date : " << d1 << "/" << m1 << "/" << y1 ;
gotoxy(72,1) ;
cout <<"<0>=Sortie" ;
gotoxy(5,5) ;
cout << "Entrez le code ou le nom du livre à émettre" ;
gotoxy(5,6) ;
cout <<" ou " ;
gotoxy(5,7) ;
cout << "Appuyez sur <ENTRER> pour de l'aide ";
gets(t1code) ;
si (t1code[0] == '0')
retourner ;
si (strlen(t1code) == 0)
[Link]() ;
sinon
pause ;
}
t2code = atoi(t1code) ;
tcode = t2code ;
si ((tcode == 0 && !bookname_found(t1code)) || (tcode != 0
&& !livre_trouvé(tcode)))
{
valid = 0 ;
gotoxy(5,10) ;
Enregistrement non trouvé
gotoxy(5,11) ;
cout <<"Appuyez sur <ESC> pour quitter ou sur une autre touche pour
continuer...
ch = getch() ;
si (ch == 27)
retour ;
}
}tant que (!valide) ;
si (tcode == 0)
tcode = bookcodeof(t1code) ;
si (!disponible(tcode))
{
gotoxy(5,10) ;
cout <<" Désolé ! Le livre (« <<bookname(tcode) <<") n'est pas
disponible
gotoxy(5,11) ;
Veuillez émettre un autre livre
gotoxy(5,12) ;
cout <<"Voir la liste des livres" ;
getch() ;
retourner ;
}
faire
{
valid = 1 ;
tant que (1)
{
clrscr() ;
gotoxy(72,1) ;
<<0>=Sortie
gotoxy(5,2) ;
cout << "Date : " << d1 << "/" << m1 << "/" << y1 ;

Page | 41
 gotoxy(5,5) ;
cout << "Nom du Livre : " << bookname(tcode) ;
gotoxy(5,7) ;
cout << "Entrez le numéro de code du membre" ;
gotoxy(5,8) ;
cout <<" ou ";
gotoxy(5,9) ;
Appuyez sur <ENTRÉE> pour obtenir de l'aide
gets(t1code) ;
si (t1code[0] == '0')
retourner ;
si (strlen(t1code) == 0)
[Link]() ;
sinon
pause ;
}
t2code = atoi(t1code);
mcode = t2code ;
si (mcode == 0)
{
valid = 0 ;
gotoxy(5,25) ;
cout <<" Entrez correctement" ;
getch() ;
}
si (!membre_trouvé(mcode) && valide)
{
valid = 0 ;
gotoxy(5,13) ;
cout <<" Enregistrement non trouvé" ;
gotoxy(5,14) ;
cout << "Appuyez sur <ESC> pour quitter ou sur une autre touche pour";
continue...
ch = getch() ;
si (ch == 27)
retourner ;
}
}tant que (!valide) ;
int tcopies, tavail ;
tcopies = no_of_copies(tcode) ; // member function of BOOK
tavail = available(tcode) - 1 ; // member function of BOOK
mettre_à_jour_exemplaires(tcode, tcopies, tavail); // fonction membre de LIVRE
D.extend_date(d1,m1,y1,15) ;
d1 = [Link] ;
m1 = [Link] ;
y1 = [Link] ;
mettre_à_jour_le_livre(mcode,tcode,d1,m1,y1) ; // fonction membre de MEMBRE
gotoxy(5,13) ;
cout <<" Le livre est attribué à " <<membername(mcode);
gotoxy(5,15) ;
cout <<"Date de retour : " <<d1 <<"/" <<m1 <<"/" <<y1 ;
getch() ;
}

//**********************************************************
// THIS FUNCTION RETURNS THE BOOK FOR THE MEMBER

Page | 42
//**********************************************************

void WORKING :: retournerLivre(void)

{
MEMBRE M ;
char t1code[5], ch ;
int t2code=0, mcode=0, valide ;
int d1, m1, y1 ;
struct date d;
obtenir_date(&d);
d1 = d.jour_da ;
m1 = d.da_mon ;
y1 = d.da_year ;
faire
{
valid = 1 ;
tant que (1)
{
clrscr() ;
gotoxy(72,1) ;
cout <<"<0>=Sortir" ;
gotoxy(5,2) ;
cout << "Date : " << d1 << "/" << m1 << "/" << y1 ;
gotoxy(5,7) ;
cout <<"Entrez le numéro de code du membre qui veut ";
retourner le livre
gotoxy(5,8) ;
cout <<" ou " ;
gotoxy(5,9) ;
cout <<"Appuyez sur <ENTRER> pour obtenir de l'aide ";
gets(t1code) ;
si (t1code[0] == '0')
retourner ;
si (strlen(t1code) == 0)
[Link]() ;
sinon
pause ;
}
t2code = atoi(t1code) ;
mcode = t2code ;
si (mcode == 0)
{
valid = 0 ;
gotoxy(5,25) ;
cout <<" Entrez Correctement" ;
getch() ;
}
si (!membre_trouvé(mcode) && valide)
{
valid = 0 ;
gotoxy(5,13) ;
cout <<" Enregistrement non trouvé" ;
gotoxy(5,14) ;
cout << "Appuyez sur <ESC> pour sortir ou sur une autre touche pour
continuer...
ch = getch() ;
si (ch == 27)

Page | 43
 retour ;
}
si (!émis(mcode) && valide)
{
valid = 0 ;
gotoxy(5,13) ;
cout <<" Le membre n'a aucun livre à rendre" ;
gotoxy(5,14) ;
cout << "Appuyez sur <ESC> pour quitter ou sur une autre touche pour
continue...
ch = getch() ;
si (ch == 27)
retourner ;
}
}tant que (!valide) ;
int bcode, tcopies, tavail ;
bcode = émis(mcode) ;
gotoxy(5,13) ;
cout << "Code du Livre : " << bcode ;
gotoxy(5,14) ;
cout << "Nom du livre : " << bookname(bcode) ;
tcopies = nombre_de_copies(bcode) ;
tavail = available(bcode) + 1 ;
int f ;
f = amende(mcode) ;
si (f != 0)
{
gotoxy(5,16) ;
Vous devez payer une amende de Rs.
gotoxy(5,17) ;
Veuillez ne pas retarder le retour du livre à nouveau.
}
mettre_à_jour_exemplaires(bcode,tcopies,tavail) ;
mettre_a_jour_livre(mcode,0,0,0,0) ;
gotoxy(5,19) ;
cout <<" Le livre a été retourné" ;
getch() ;
}

//**********************************************************
// CETTE FONCTION FOURNIT DES DONNÉES POUR MODIFIER L'ENREGISTREMENT DU LIVRE
//**********************************************************

void TRAVAIL :: modifier_livre(void)

{
LIVRE B
char t1code[5], tname[33], tauthor[26], *t1, ch ;
int t2code=0, tcode=0 ;
float t2=0.0, tprice=0.0 ;
int valide ;
faire
{
valid = 1 ;
tandis que (1)
{
clrscr() ;

Page | 44
 gotoxy(72,1) ;
cout <<"<0>=Sortie" ;
gotoxy(5,5) ;
cout << "Entrez le code ou le nom du livre à modifier"
;
gotoxy(5,6) ;
cout <<" ou ";
gotoxy(5,7) ;
cout <<"Appuyez sur <ENTRER> pour obtenir de l'aide ";
gets(t1code) ;
si (t1code[0] == '0')
retourner ;
si (strlen(t1code) == 0)
[Link]() ;
sinon
pause ;
}
t2code = atoi(t1code) ;
tcode = t2code ;
si ((tcode == 0 && !bookname_found(t1code)) || (tcode != 0
&& !livre_trouvé(tcode)))
{
valid = 0 ;
gotoxy(5,10) ;
cout <<" Enregistrement non trouvé" ;
gotoxy(5,11) ;
cout << "Appuyez sur <ESC> pour quitter ou sur une autre touche pour
continuer...
ch = getch();
si (ch == 27)
retourner ;
}
}tant que (!valide) ;
si (tcode == 0)
tcode = codeDuLivre(t1code) ;
clrscr() ;
gotoxy(72,1) ;
cout <<"<0>=Sortie" ;
LIVRE::afficher(tcode) ;
faire
{
gotoxy(5,13) ; clreol() ;
cout << "Voulez-vous modifier cet enregistrement (o/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
si (ch == '0')
retour ;
}tant que (ch != 'Y' && ch != 'N');
si (ch == 'N')
retourner ;
gotoxy(5,16) ;
Nom du livre :
gotoxy(5,17) ;
cout << "Nom de l'auteur : " ;
gotoxy(5,18) ;
cout << "Prix : Rs." ;
faire

Page | 45
 {
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le nom du livre ou <ENTRER> pour aucun changement"
;
gotoxy(19,16) ; clreol() ;
obtient(tname) ;
strupr(tname) ;
si (tname[0] == '0')
retourner ;
si (strlen(tname) > 32)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement (Plage : 1..32)" ;
getch() ;
}
}tant que (!valide) ;
si (strlen(tname) == 0)
strcpy(tname,bookname(tcode)) ;
faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le nom de l'auteur ou <ENTRÉE> pour ne pas changer" ;
gotoxy(19,17) ; clreol() ;
gets(tauthor) ;
strupr(tauthor) ;
si (tauthor[0] == '0')
retourner ;
si (strlen(tauthor) > 25)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
Entrez correctement (Plage : 1..25)
getch() ;
}
}tant que (!valide) ;
si (strlen(tauthor) == 0)
strcpy(tauthor,auteurnom(tcode)) ;
faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout << "Entrez le prix ou <ENTRER> pour aucun changement" ;
gotoxy(22,18) ; clreol() ;
gets(t1) ;
t2 = atof(t1) ;
tprice = t2 ;
si (t1[0] == '0')
retourner ;
si (strlen(t1) == 0)
pause ;
si (tprice < 1 || tprice > 9999)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;

Page | 46
 Entrez correctement
getch() ;
}
}tant que (!valide) ;
si (strlen(t1) == 0)
prix = prixLivre(tcode) ;
gotoxy(5,25) ; clreol() ;
faire
{
gotoxy(5,20) ; clreol() ;
Voulez-vous enregistrer les modifications (o/n) :
ch = getche() ;
ch = toupper(ch) ;
si (ch == '0')
retourner ;
}tant que (ch != 'Y' && ch != 'N') ;
si (ch == 'N')
retourner ;
LIVRE::modifier(tcode,tname,tauthor,tprice) ;
gotoxy(5,23) ;
Enregistrement modifié
getch() ;
}

//**********************************************************
// CETTE FONCTION DONNE DES DONNÉES POUR MODIFIER LE DOSSIER DU MEMBRE
//**********************************************************

void TRAVAIL :: modifier_membre(void)

{
MEMBER M ;
char m1code[10], mname[26], mphone[10], maddress[33], ch ;
int m2code=0, mcode=0 ;
int valide ;
faire
{
valid = 1 ;
tant que (1)
{
clrscr() ;
gotoxy(72,1) ;
cout <<"<0>=Sortir" ;
gotoxy(5,7) ;
cout << "Entrez le numéro de code du membre à modifier" ;
gotoxy(5,8) ;
cout <<" ou " ;
gotoxy(5,9) ;
cout << "Appuyez sur <ENTRÉE> pour de l'aide ";
obtenir(m1code) ;
m2code = atoi(m1code) ;
mcode = m2code ;
si (m1code[0] == '0')
retourner ;
si (strlen(m1code) == 0)
[Link]() ;
sinon

Page | 47
 pause ;
}
si (mcode == 0)
{
valid = 0 ;
gotoxy(5,25) ;
cout <<" Entrez correctement" ;
getch() ;
}
si (valide && !membre_trouvé(mcode))
{
valid = 0 ;
gotoxy(5,13) ;
cout <<" Enregistrement non trouvé" ;
gotoxy(5,14) ;
Appuyez sur <ESC> pour quitter ou sur une autre touche pour
continue...
ch = getch() ;
si (ch == 27)
retourner ;
}
}tant que (!valide) ;
clrscr() ;
gotoxy(72,1) ;
cout <<"<0>=Sortie" ;
MEMBRE::afficher(mcode) ;
faire
{
gotoxy(5,10) ; clreol() ;
cout << "Voulez-vous modifier cet enregistrement (o/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
si (ch == '0')
retour ;
}tandis que (ch != 'Y' && ch != 'N') ;
si (ch == 'N')
retour ;
gotoxy(5,13) ;
cout <<"Nom : ";
gotoxy(5,14) ;
téléphone :
gotoxy(5,15) ;
cout << "Adresse : " ;
faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout <<"Entrez le nom du membre ou <ENTRER> pour aucun
changer
gotoxy(19,13) ; clreol() ;
gets(mname) ;
strupr(mname) ;
si (mname[0] == '0')
retourner ;
si (strlen(mname) > 25)
{
valid = 0 ;

Page | 48
 gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement (Plage : 1..25)" ;
getch();
}
}
tant que (!valide) ;
si (strlen(mname) == 0)
strcpy(mname,membername(mcode)) ;
faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
cout <<"Entrez le numéro de téléphone du membre ou <ENTRER> pour aucun"
changer
gotoxy(19,14) ; clreol() ;
obtient(mphone) ;
si (mphone[0] == '0')
return ;
si ((strlen(mphone) < 7 && strlen(mphone) > 0) ||
(strlen(mphone) > 9))
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement" ;
getch();
}
}tant que (!valide) ;
si (strlen(mphone) == 0)
strcpy(mphone,membretelephone(mcode)) ;
faire
{
valid = 1 ;
gotoxy(5,25) ; clreol() ;
Entrez l'adresse du membre ou <ENTRER> pour rien
changer
gotoxy(19,15) ; clreol() ;
gets(madresse) ;
strupr(madresse);
si(maddress[0]=='0')
retour ;
si (strlen(maddress) > 32)
{
valid = 0 ;
gotoxy(5,25) ; clreol() ;
cout <<" Entrez correctement (Plage : 1..32)" ;
getch() ;
}
}tant que (!valide) ;
si (strlen(madresse) == 0)
strcpy(maddress,membreadresse(mcode)) ;
gotoxy(5,25) ; clreol() ;
faire
{
gotoxy(5,18) ; clreol() ;
cout <<"Voulez-vous enregistrer les modifications (o/n) : ";
ch = getche();
ch = toupper(ch) ;

Page | 49
 si (ch == '0')
retourner ;
}tant que (ch != 'Y' && ch != 'N') ;
si (ch == 'N')
retourner ;
MEMBER::modify(mcode,mname,mphone,maddress) ;
gotoxy(5,23) ;
Enregistrement Modifié
getch() ;
}

//**********************************************************
// THIS FUNCTION GIVES BOOK CODE TO DELETE THE BOOK RECORD
//**********************************************************

void WORKING :: supprimer_livre(void)

{
LIVRE B
char t1code[5], tname[33], tauthor[26], ch ;
int t2code=0, tcode=0 ;
int valide ;
faire
{
valid = 1 ;
tant que (1)
{
effacer() ;
gotoxy(72,1) ;
cout <<"<0>=Sortie" ;
gotoxy(5,5) ;
cout << "Entrez le code ou le nom du livre à "
Supprimé
gotoxy(5,6) ;
cout <<" ou ";
gotoxy(5,7) ;
Appuyez sur <ENTRÉE> pour de l'aide
obtenir(t1code) ;
si (t1code[0] == '0')
retourner ;
si (strlen(t1code) == 0)
[Link]() ;
sinon
pause ;
}
t2code = atoi(t1code) ;
tcode = t2code ;
si ((tcode == 0 && !bookname_found(t1code)) || (tcode != 0
&& !livre_trouvé(tcode)))
{
valid = 0 ;
gotoxy(5,10) ;
cout <<" Enregistrement non trouvé" ;
gotoxy(5,11) ;
cout << "Appuyez sur <ESC> pour quitter ou sur une autre touche pour
continuer...
ch = getch() ;

Page | 50
 si (ch == 27)
retourner ;
}
}tandis que (!valide) ;
si (tcode == 0)
tcode = codeLivreDe(t1code) ;
clrscr() ;
gotoxy(72,1) ;
cout <<"<0>=Sortir" ;
LIVRE::afficher(tcode) ;
faire
{
gotoxy(5,13) ; clreol() ;
cout << "Voulez-vous supprimer cet enregistrement (o/n) : ";
ch = getche() ;
ch = toupper(ch) ;
si (ch == '0')
retour ;
}while (ch != 'Y' && ch != 'N') ;
si (ch == 'N')
retour ;
int travail, tcopies ;
tavail = available(tcode) ;
tcopies = no_of_copies(tcode) ;
si (tavail != tcopies)
{
gotoxy(5,15) ;
cout <<" L'enregistrement ne peut pas être supprimé. Ce livre est emprunté." ;
getch();
retourner ;
}
LIVRE::supprimer_rec(tcode) ;
gotoxy(5,23) ;
cout <<" Enregistrement supprimé" ;
getch() ;
}

//**********************************************************
// CETTE FONCTION ATTRIBUE UN CODE DE MEMBRE POUR SUPPRIMER LE MEMBRE
// ENREGISTRER
//**********************************************************

void TRAVAIL :: supprimer_membre(void)

{
MEMBER M ;
char m1code[5], mname[26], mphone[10], maddress[33], ch ;
int m2code=0, mcode=0 ;
int valide ;
faire
{
valid = 1 ;
tant que (1)
{
clrscr() ;
gotoxy(72,1) ;
cout <<"<0>=Sortie" ;

Page | 51
 gotoxy(5,7) ;
cout << "Entrez le numéro de code du membre à supprimer" ;
gotoxy(5,8) ;
cout <<" ou " ;
gotoxy(5,9) ;
Appuyez sur <ENTREE> pour obtenir de l'aide
gets(m1code) ;
m2code = atoi(m1code) ;
mcode = m2code ;
si (m1code[0] == '0')
retour ;
si (strlen(m1code) == 0)
[Link]() ;
sinon
pause ;
}
si (mcode == 0)
{
valid = 0 ;
gotoxy(5,25) ;
cout <<" Entrez correctement" ;
getch() ;
}
si (valide && !membre_trouvé(mcode))
{
valide = 0 ;
gotoxy(5,13) ;
cout <<" Enregistrement non trouvé" ;
gotoxy(5,14) ;
cout << "Appuyez sur <ESC> pour quitter ou sur une autre touche pour " ;
continue...
ch = getch() ;
si (ch == 27)
retour ;
}
}tant que (!valide) ;
clrscr() ;
gotoxy(72,1) ;
cout <<"<0>=Quitter" ;
MEMBRE::afficher(mcode) ;
faire
{
gotoxy(5,10) ; clreol() ;
cout <<"Do you want to Delete this record (y/n) : " ;
ch = getche() ;
ch = toupper(ch) ;
si (ch == '0')
retourner ;
}tant que (ch != 'Y' && ch != 'N') ;
si (ch == 'N')
retourner ;
si (émis(mcode))
{
gotoxy(5,15) ;
cout << " L'enregistrement ne peut pas être supprimé. Le membre a un livre";
getch() ;
retour ;

Page | 52
 }
MEMBRE::supprimer_enr(mcode) ;
gotoxy(5,23) ;
cout <<" Enregistrement Modifié" ;
getch() ;
}

//**********************************************************
// APPEL DE LA FONCTION PRINCIPALE INTRODUCTION ET MENU PRINCIPAL
//**********************************************************

void main(void)
{
MENU menu ;
[Link]() ;
menu.menu_principal() ;
}

SORTIE

Page | 53
Page | 54
Menu principal du programme.

Page | 55
Dans le menu principal, le choix 1 est sélectionné.

Page | 56
le choix 5 est sélectionné.

Page | 57
Dans le menu principal, le choix 3 est sélectionné.

Page | 58
Le choix 5 est sélectionné.

Page | 59
Le choix 6 est sélectionné pour émettre un livre à l'étudiant.

Page | 60
Le choix 5 est sélectionné pour montrer les changements dans les informations de l'étudiant après l'émission d'un
livre.

Test

Page | 61
 C'est une partie intégrante du cycle de vie de développement de tout système, sans lequel le
le système développé est sûr de faillir et de provoquer une perte économique et
investissements en main-d'œuvre en plus de l'insatisfaction des utilisateurs et de la chute de
réputation.

Les tests système sont l'étape de mise en œuvre qui vise à garantir que
Le système fonctionne avec précision et efficacité avant l'opération réelle.
commences. No program or system design is perfect, communication
entre l'utilisateur et le designer n'est pas toujours complet ou clair. Tout cela
peut entraîner des erreurs.

Une autre raison pour le test système est son utilité en tant que véhicule orienté vers l'utilisateur.
avant la mise en œuvre. Le système d'application n'a aucune valeur s'il ne répond pas
les besoins de l'utilisateur, ainsi le système doit être testé pour voir s'il répond à l'utilisateur
exigences.

Les tests ici sont réalisés selon une approche ascendante comme suit :
Module testing: Here testing is done at each module level. Each case
a été soigneusement testé pour découvrir les pièges.
Tests système : Les tests sont effectués après que tous les modules ont été
intégré.

Bibliographie

Page | 62
1. Laissez-nous C par Yashavant Kanetkar
2. Informatique, C++ par Sumita Arora
3. La référence complète, C++ par Herbert Schildt
4. Ingénierie logicielle par Roger S. Pressman

Page | 63