Skip to content
Snippets Groups Projects
Commit 42784244 authored by Adrien L's avatar Adrien L
Browse files

Final stage

parents e041cffc 95065536
Branches master
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 388 additions and 428 deletions
Compte rendu - TP 1 SDD.docx.pdf 0 → 100644
+ 0
− 0
View file @ 42784244
File added
Compte_Rendu_TP1.pdf deleted 100644 → 0
+ 0
− 0
View file @ e041cffc
File deleted
Makefile
+ 6
− 3
View file @ 42784244
.PHONY: help all clean
.PHONY: help all clean launch
.DEFAULT_GOAL = all
EXE=app
......@@ -9,7 +9,7 @@ CC=gcc
FLAGS=-g -Wall -Wextra
LIBS=-lm
help: ## Display the availables commands
help: ## Display the available commands
@grep -E '(^[a-zA-Z_-]+:.*?##.*$$)|(^##)' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[32m%-10s\033[0m %s\n", $$1, $$2}' | sed -e 's/\[32m##/[33m/'
all: $(OBJ) ## Run the compilation of the app
......@@ -21,3 +21,6 @@ build/%.o: src/%.c
clean: ## Clean all .object files
rm -f build/*.o $(EXE)
launch: ## Launch the program
make clean && make && valgrind ./app donnee.txt
\ No newline at end of file
emprunts_ajout.txt
+ 3
− 3
View file @ 42784244
17 20200228
23 20200228
11 20200228
17 20202803
23 20202803
11 20202803
emprunts_suppr.txt
+ 2
− 2
View file @ 42784244
17 20200228
23 20200228
17 20202803
23 20202803
src/biblio.c
+ 93
− 26
View file @ 42784244
......@@ -7,25 +7,83 @@
#include "utils.h"
/* -------------------------------------------------------------------- */
/* creerBiblio Creer une biblio vide */
/* creerBiblio Créer une biblio vide */
/* */
/* principe: Sert de base en cas de structures de liste plus complexes */
/* */
/* En entrée: */
/* */
/* En sortie: Un pointeur pointant vers NULL */
/* -------------------------------------------------------------------- */
biblio_t creerBiblio(){
biblio_t creerBiblio()
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* chargement Lis et ajoute les données d'un fichier dans la liste */
/* recherche */
/* */
/* Recherche une cellule */
/* */
/* principe: Parcours la liste tant que la place de l'élément */
/* n'est pas trouvée */
/* */
/* En entrée: La liste et le critère de recherche */
/* */
/* En sortie: Retourne un pointeur de pointeur sur la cellule précédente*/
/* */
/* Vars locales : categ_tmp : ptr temporaire pour le parcours */
/* livre_cour : ptr temporaire pour le parcours */
/* estTrouve : booléen indiquant si un élmt a été trouvé */
/* -------------------------------------------------------------------- */
livre_t *rechercheLivre(biblio_t biblio, int num)
{
categ_t *categ_tmp = biblio;
livre_t *livre_cour = NULL;
int estTrouve = 0;
while (!estTrouve && categ_tmp != NULL)
{
livre_cour = categ_tmp->liste;
while (!estTrouve && livre_cour != NULL && livre_cour->num <= num)
{
if (livre_cour->num == num)
{
estTrouve = 1;
}
else {
livre_cour = livre_cour->suiv;
}
}
categ_tmp = categ_tmp->suiv;
}
return livre_cour;
}
/* -------------------------------------------------------------------- */
/* chargementBiblio Lis et ajoute les données du fichier dans la liste */
/* */
/* principe: Lis le nb de livres sur la 1ère ligne et insère en boucle */
/* les catégories en tête puis les livres en queue */
/* */
/* En entrée: liste : liste de cellule */
/* En entrée: biblio : liste de cellule */
/* fichier : nom du fichier à lire */
/* */
/* En sortie: Code de retour de la fonction */
/* */
/* Vars locales : flot : descripteur de fichier pour la lecture */
/* i : variable d'itération dans le for */
/* code : code de retour d'exécution */
/* num_livre : variable de stockage pendant la lecture */
/* nb_livres : variable de stockage pendant la lecture */
/* titre : variable de stockage pendant la lecture */
/* nom : variable de stockage pendant la lecture */
/* livre_tmp : ptr temporaire pour le parcours */
/* livre_prec : ptr temporaire sur le maillon précédent */
/* -------------------------------------------------------------------- */
int chargementBiblio(biblio_t *biblio, char *fichier){
int chargementBiblio(biblio_t * biblio, char * fichier)
{
FILE * flot = fopen(fichier, "r");
int i, code, num_livre, nb_livres;
char titre [20], nom[3];
......@@ -47,11 +105,9 @@ int chargementBiblio(biblio_t *biblio, char *fichier){
for(i = 0; i < nb_livres; ++i) {
fscanf(flot, "%d\t", &num_livre);
fgets(titre, 11, flot);
fgets(titre, 20, flot);
if(titre[strlen(titre) - 1] == '\n') {
titre[strlen(titre) - 1] = '\0';
}
titre[strcspn(titre, "\r\n")] = 0;
livre_tmp = sddalloc(sizeof(livre_t));
strcpy(livre_tmp->titre, titre);
......@@ -79,39 +135,50 @@ int chargementBiblio(biblio_t *biblio, char *fichier){
/* -------------------------------------------------------------------- */
/* afficherBiblio Affiche la liste */
/* */
/* principe: Parcourt la liste jusqu'à NULL et affiche */
/* */
/* En entrée: biblio : liste de cellules à afficher */
/* flux : flux de sortie */
/* */
/* En sortie: */
/* */
/* Vars locales : categ_tmp : ptr temporaire pour le parcours */
/* livre_tmp : ptr temporaire pour le parcours */
/* -------------------------------------------------------------------- */
void afficherBiblio(biblio_t biblio, FILE * stream){
void afficherBiblio(biblio_t biblio, FILE * flux)
{
categ_t * categ_tmp = biblio;
livre_t * livre_tmp;
/*puts("\n--------------------- START --------------------------");*/
while(categ_tmp != NULL){
printf("%s %d\n", categ_tmp->nom, strlen(categ_tmp->nom));
fprintf(stream, "%s\n", categ_tmp->nom);
fprintf(flux, "%s\n", categ_tmp->nom);
livre_tmp = categ_tmp->liste;
while(livre_tmp != NULL) {
printf("%s %d\n", livre_tmp->titre, strlen(livre_tmp->titre));
fprintf(stream, "%d\t%s\n", livre_tmp->num, livre_tmp->titre);
fprintf(flux, "%d\t%s\n", livre_tmp->num, livre_tmp->titre);
livre_tmp = livre_tmp->suiv;
}
categ_tmp = categ_tmp->suiv;
}
/*puts("--------------------- END --------------------------\n");*/
}
/* -------------------------------------------------------------------- */
/* libererBiblio Libère la mémoire allouée pour la biblio */
/* */
/* principe: Parcourt les listes jusqu'à NULL en libérant la mémoire */
/* */
/* En entrée: biblio : liste de cellules */
/* */
/* En sortie: */
/* */
/* Vars locales : categ_cour : ptr courant pour le parcours */
/* categ_tmp : ptr temporaire pour la suppression */
/* livre_cour : ptr courant pour la suppression */
/* livre_tmp : ptr temporaire pour la suppression */
/* -------------------------------------------------------------------- */
void libererBiblio(biblio_t biblio){
void libererBiblio(biblio_t biblio)
{
categ_t * categ_cour = biblio, *categ_tmp;
livre_t * livre_cour, *livre_tmp;
......
src/biblio.h
+ 10
− 0
View file @ 42784244
#ifndef BIBLIO_H
#define BIBLIO_H
/* ------------------------------------ */
/* Structure de liste */
/* ------------------------------------ */
typedef struct livre {
int num;
char titre[11];
......@@ -8,13 +11,20 @@ typedef struct livre {
struct livre* suiv;
} livre_t, *catalogue_t;
/* ------------------------------------ */
/* Structure de liste */
/* ------------------------------------ */
typedef struct categ {
char nom[4];
catalogue_t liste;
struct categ* suiv;
} categ_t, *biblio_t;
/* -------------------------------- */
/* Prototypes */
/* -------------------------------- */
biblio_t creerBiblio();
livre_t * rechercheLivre(biblio_t, int);
int chargementBiblio(biblio_t *, char *);
void afficherBiblio(biblio_t, FILE *);
void libererBiblio(biblio_t);
......
src/emprunts.c
+ 135
− 59
View file @ 42784244
......@@ -5,9 +5,12 @@
#include <time.h>
#include "emprunts.h"
#include "utils.h"
#define __DEBUG__ 1
/* -------------------------------------------------------------------- */
/* creerListe Creer une liste vide */
/* creerEmprunts Creer une liste vide */
/* */
/* Principe: Sert de base en cas de structures de liste plus complexes */
/* */
/* En entrée: */
/* */
......@@ -19,14 +22,16 @@ liste_emprunts creerEmprunts()
}
/* -------------------------------------------------------------------- */
/* creerCellule */
/* creerEmprunt Creer un emprunt contenant un numéro et une date */
/* */
/* Creer un emprunt contenant deux dates et un message */
/* Principe: Alloue une cellule et la remplie avec les vars fournies */
/* */
/* En entrée: num : numéro du livre emprunté */
/* date_retour : date à laquelle le livre doit être retourné */
/* */
/* En sortie: Retourne un pointeur sur l'emprunt créé */
/* */
/* Vars locales : tmp : ptr temporaire sur la nouvelle cellule créée */
/* -------------------------------------------------------------------- */
emprunt_t *creerEmprunt(int num, int date_retour)
{
......@@ -38,40 +43,24 @@ emprunt_t *creerEmprunt(int num, int date_retour)
}
/* -------------------------------------------------------------------- */
/* rechercheDateRetourPrecedent */
/* recherchePrecedent */
/* */
/* Recherche la cellule précédant la position d'insertion */
/* de la cellule recherchée passée en paramètres */
/* */
/* En entrée: La liste et la cellule recherchée */
/* */
/* En sortie: Retourne un pointeur de pointeur sur la cellule précédente*/
/* -------------------------------------------------------------------- */
emprunt_t **rechercheDateRetourPrecedent(liste_emprunts *liste, emprunt_t *cellule)
{
emprunt_t *cour = *liste, **prec = liste;
while (cour != NULL && cour->date_retour < cellule->date_retour)
{
prec = &(cour->suiv);
cour = cour->suiv;
}
return prec;
}
/* -------------------------------------------------------------------- */
/* rechercheNumPrecedent */
/* */
/* Recherche la cellule précédant la position d'insertion */
/* de la cellule recherchée passée en paramètres */
/* Principe: Parcours la liste tant que la place de l'élément */
/* n'est pas trouvée */
/* */
/* En entrée: La liste et la cellule recherchée */
/* */
/* En sortie: Retourne un pointeur de pointeur sur la cellule précédente*/
/* */
/* Vars locales : cour : ptr temporaire sur la cellule de parcours */
/* -------------------------------------------------------------------- */
emprunt_t **rechercheNumPrecedent(liste_emprunts *liste, emprunt_t *cellule)
emprunt_t **recherchePrecedent(liste_emprunts *liste, int num)
{
emprunt_t **cour = liste;
while (*cour != NULL && (*cour)->num < cellule->num)
while (*cour != NULL && (*cour)->num < num)
{
cour = &((*cour)->suiv);
}
......@@ -81,6 +70,8 @@ emprunt_t **rechercheNumPrecedent(liste_emprunts *liste, emprunt_t *cellule)
/* -------------------------------------------------------------------- */
/* inserer Insère une cellule dans la liste de cellules */
/* */
/* Principe: Reforme le chaînage entre cellule et prec */
/* */
/* En entrée: */
/* cellule : pointeur sur la cellule que l'on ajoute */
/* dans la liste */
......@@ -98,35 +89,107 @@ void inserer(emprunt_t *cellule, emprunt_t **prec)
/* -------------------------------------------------------------------- */
/* supprimer Supprime un élément de la liste */
/* */
/* Principe: Reforme le chaînage entre prec/suiv et libère la cellule */
/* */
/* En entrée: prec : cellule à supprimer */
/* */
/* En sortie: */
/* -------------------------------------------------------------------- */
void supprimer(emprunt_t **prec)
{
if(*prec) {
emprunt_t *tmp = *prec;
(*prec) = (*prec)->suiv;
free(tmp);
}
}
/* -------------------------------------------------------------------- */
/* verifier Effectue un contrôle des données et insère/suppr */
/* */
/* Principe: Vérifie qu'un emprunt n'existe pas déjà */
/* et que le livre existe */
/* */
/* En entrée: emprunts : liste des emprunts */
/* existant : résultat de la recherche dans la biblio */
/* nouvel_emprunt : nouvelle cellule d'emprunt */
/* insertion : booléen pour insertion ou suppression */
/* */
/* En sortie: code de retour de l'exécution */
/* */
/* Vars locales : emprunt : ptr temporaire sur le nouvel emprunt créé */
/* code : code de retour d'exécution */
/* -------------------------------------------------------------------- */
int verifier(liste_emprunts * emprunts, livre_t * existant, int num, int date_retour, int insertion)
{
emprunt_t * emprunt;
int code = EXIT_SUCCESS;
if (existant != NULL)
{
if (insertion)
{
if (existant->est_emprunte == 0)
{
existant->est_emprunte = 1;
emprunt = creerEmprunt(num, date_retour);
inserer(emprunt, recherchePrecedent(emprunts, num));
}
else
{
fprintf(stderr, "Livre déjà emprunté\n");
code = EXIT_FAILURE;
}
}
else
{
existant->est_emprunte = 0;
supprimer(recherchePrecedent(emprunts, num));
}
}
else
{
fprintf(stderr, "Livre inexistant\n");
code = EXIT_FAILURE;
}
return code;
}
/* -------------------------------------------------------------------- */
/* chargement Lis et ajoute les données d'un fichier dans la liste */
/* chargementEmprunts Lis et ajoute les données du fichier dans la liste*/
/* */
/* Principe: Détermine si c'est une insertion ou non */
/* puis lis le fichier indiqué en insérant ou supprimant */
/* les cellules créée à partir du fichier */
/* */
/* En entrée: liste : liste de cellule */
/* fichier : nom du fichier à lire */
/* insertion : booléen pour insertion/suppression */
/* */
/* En sortie: Code de retour de la fonction */
/* */
/* Vars locales : flot : descripteur de fichier pour la lecture */
/* code : code de retour d'exécution */
/* num : variable de stockage pendant la lecture */
/* date_retour : variable de stockage pendant la lecture */
/* fichier : variable contenant le nom du fichier à lire */
/* -------------------------------------------------------------------- */
int chargementEmprunts(liste_emprunts *emprunts, int insertion)
int chargementEmprunts(biblio_t biblio, liste_emprunts * emprunts, int insertion)
{
FILE * flot;
int code, num, date_retour;
emprunt_t *tmp;
char fichier[255];
printf("Indiquez le fichier :");
scanf("%s%*c", fichier);
if (__DEBUG__)
{
strcpy(fichier, insertion ? "emprunts_ajout.txt" : "emprunts_suppr.txt");
}
else {
printf("Indiquez le fichier :\t");
scanf("%s", fichier);
}
flot = fopen(fichier, "r");
if (flot == NULL)
......@@ -139,15 +202,7 @@ int chargementEmprunts(liste_emprunts *emprunts, int insertion)
fscanf(flot, "%d\t%d", &num, &date_retour);
while (!feof(flot))
{
tmp = creerEmprunt(num, date_retour);
if(insertion) {
inserer(tmp, rechercheNumPrecedent(emprunts, tmp));
}
else {
supprimer(rechercheNumPrecedent(emprunts, tmp));
}
verifier(emprunts, rechercheLivre(biblio, num), num, date_retour, insertion);
fscanf(flot, "%d\t%d", &num, &date_retour);
}
......@@ -161,9 +216,16 @@ int chargementEmprunts(liste_emprunts *emprunts, int insertion)
/* -------------------------------------------------------------------- */
/* sauvegarder Sauvegarde la liste de cellule dans un fichier */
/* */
/* Principe: Sauvegarde cellule par cellule en écrivant chaque ligne */
/* dans le fichier */
/* */
/* En entrée: liste liste de cellule à sauvegarder dans le fichier */
/* */
/* En sortie: */
/* En sortie: Code de retour de la fonction */
/* */
/* Vars locales : tmp : ptr temporaire pour le parcours */
/* flot : descripteur de fichier pour la lecture */
/* code : code de retour d'exécution */
/* -------------------------------------------------------------------- */
int sauvegarder(liste_emprunts liste){
emprunt_t *tmp = liste;
......@@ -192,28 +254,36 @@ int sauvegarder(liste_emprunts liste){
/* -------------------------------------------------------------------- */
/* afficherEmprunts Affiche les emprunts */
/* */
/* Principe: Parcourt la liste jusqu'à la fin et l'affiche */
/* */
/* En entrée: emprunts : liste des emprunts à afficher */
/* flux : flux de sortie */
/* */
/* En sortie: */
/* */
/* Vars locales : tmp : ptr temporaire pour le parcours */
/* -------------------------------------------------------------------- */
void afficherEmprunts(liste_emprunts emprunts)
void afficherEmprunts(liste_emprunts emprunts, FILE * stream)
{
emprunt_t *tmp = emprunts;
puts("\n--------------------- START --------------------------");
while (tmp != NULL)
{
printf("%d %d\n", tmp->num, tmp->date_retour);
fprintf(stream, "%d\t%d\n", tmp->num, tmp->date_retour);
tmp = tmp->suiv;
}
puts("--------------------- END --------------------------\n");
}
/* -------------------------------------------------------------------- */
/* libererEmprunts Libère la mémoire allouée pour les emprunts */
/* */
/* Principe: Parcourt la liste tout en libérant chaque cellule */
/* */
/* En entrée: emprunts : liste des emprunts */
/* */
/* En sortie: */
/* */
/* Vars locales : cour : ptr temporaire pour le parcours */
/* tmp : ptr temporaire pour la libération de mémoire */
/* -------------------------------------------------------------------- */
void libererEmprunts(liste_emprunts emprunts)
{
......@@ -229,25 +299,31 @@ void libererEmprunts(liste_emprunts emprunts)
/* -------------------------------------------------------------------- */
/* afficherEmpruntsParDate Affiche les emprunts */
/* */
/* Principe: Parcourt la liste jusqu'à la fin et affiche si la */
/* la condition est valide */
/* */
/* En entrée: emprunts : liste des emprunts à afficher */
/* */
/* En sortie: */
/* */
/* Vars locales : tmp : ptr temporaire pour le parcours */
/* -------------------------------------------------------------------- */
void afficherEmpruntsParDate(liste_emprunts emprunts)
void afficherEmpruntsParDate(liste_emprunts emprunts, FILE * flux)
{
emprunt_t *tmp = emprunts;
int date;
int date = 20202903;
if (!__DEBUG__)
{
printf("Indiquer la date : ");
scanf("%d", &date);
}
puts("\n--------------------- START --------------------------");
while (tmp != NULL)
{
if(tmp->date_retour < date) {
printf("%d %d\n", tmp->num, tmp->date_retour);
fprintf(flux, "%d\t%d\n", tmp->num, tmp->date_retour);
}
tmp = tmp->suiv;
}
puts("--------------------- END --------------------------\n");
}
src/emprunts.h
+ 16
− 8
View file @ 42784244
#ifndef EMPRUNTS_H
#define EMPRUNTS_H
#include "biblio.h"
/* ------------------------------------ */
/* Structure de liste */
/* ------------------------------------ */
typedef struct emprunt
{
int num;
......@@ -8,16 +13,19 @@ typedef struct emprunt
struct emprunt *suiv;
} emprunt_t, *liste_emprunts;
/* -------------------------------- */
/* Prototypes */
/* -------------------------------- */
liste_emprunts creerEmprunts();
emprunt_t *creerEmprunt(int, int);
emprunt_t **rechercheDateRetourPrecedent(liste_emprunts *, emprunt_t *);
emprunt_t **rechercheNumPrecedent(liste_emprunts *, emprunt_t *);
int verifier(liste_emprunts *, livre_t *, int, int, int);
emprunt_t **recherchePrecedent(liste_emprunts *, int);
void inserer(emprunt_t *, emprunt_t **);
void supprimer(emprunt_t **prec);
int chargementEmprunts(liste_emprunts *, int);
int chargementEmprunts(biblio_t, liste_emprunts *, int);
int sauvegarder(liste_emprunts);
void afficherEmprunts(liste_emprunts);
void afficherEmprunts(liste_emprunts, FILE *);
void libererEmprunts(liste_emprunts);
void afficherEmpruntsParDate(liste_emprunts);
void afficherEmpruntsParDate(liste_emprunts, FILE *);
#endif
\ No newline at end of file
src/main.c
+ 94
− 22
View file @ 42784244
......@@ -7,39 +7,111 @@
#include "teZZt.h"
/* -------------------------------------------------------------------- */
/* TESTS DÉBUT Batterie de tests */
/* TESTS DÉBUT Jeux de tests */
/* -------------------------------------------------------------------- */
BEGIN_TEST_GROUP(tp1)
TEST(BIBLIO, "Tests bibliothèque") {
/*Cas Général*/
char buffer[1024] = "", resultat [] = "BD\n21\ttintin\n23\ttiteuf\nPOL\n11\tle tueur\n15\tla victime\n17\tle truand\n";
FILE * file = fmemopen(buffer, 1024, "w");
biblio_t biblio = creerBiblio();
char
buffer[1024] = "",
resultatGeneral[] = "BD\n21\ttintin\n23\ttiteuf\nPOL\n11\tle tueur\n15\tla victime\n17\tle truand\n",
resultatVide[] = "",
resultatEmpruntsGeneral[] = "11\t20202803\n17\t20202803\n23\t20202803\n",
resultatEmpruntsSuppr[] = "11\t20202803\n",
resultatEmpruntsParDate[] = "11\t20202803\n";
FILE * file;
biblio_t biblio;
liste_emprunts emprunts;
/********* Cas de la bibliothèque *********/
/*Cas général*/
biblio = creerBiblio();
file = fmemopen(buffer, 1024, "w");
CHECK(biblio == NULL);
CHECK(chargementBiblio(&biblio, "donnee.txt") == EXIT_SUCCESS);
afficherBiblio(biblio, file);
fclose(file);
CHECK(!strcmp(buffer, resultatGeneral));
libererBiblio(biblio);
strcpy(buffer, "");
/*Cas général*/
/*Cas Fichier inexistant*/
biblio = creerBiblio();
CHECK(chargementBiblio(&biblio, "inexistant.txt") == EXIT_FAILURE);
libererBiblio(biblio);
/*Cas Fichier inexistant*/
//afficherBiblio(biblio, stdout);
/*Cas Fichier vide*/
biblio = creerBiblio();
file = fopen("vide.txt", "w");
fclose(file);
CHECK(chargementBiblio(&biblio, "vide.txt") == EXIT_SUCCESS);
file = fmemopen(buffer, 1024, "w");
afficherBiblio(biblio, file);
fclose(file);
CHECK(!strcmp(buffer, resultatVide));
libererBiblio(biblio);
strcpy(buffer, "");
remove("vide.txt");
/*Cas Fichier vide*/
/********* Cas de la bibliothèque *********/
/********* Cas des emprunts *********/
biblio = creerBiblio();
chargementBiblio(&biblio, "donnee.txt");
/*Cas général*/
emprunts = creerEmprunts();
file = fmemopen(buffer, 1024, "w");
CHECK(emprunts == NULL);
CHECK(chargementEmprunts(biblio, &emprunts, 1) == EXIT_SUCCESS);
afficherEmprunts(emprunts, file);
fclose(file);
CHECK(!strcmp(buffer, resultatEmpruntsGeneral));
strcpy(buffer, "");
/*Cas général*/
/*Cas livre inexistant*/
CHECK(verifier(&emprunts, rechercheLivre(biblio, 42), 42, 20202803, 1) == EXIT_FAILURE);
/*Cas livre inexistant*/
/*Cas livre déjà emprunté*/
CHECK(verifier(&emprunts, rechercheLivre(biblio, 23), 23, 20202803, 1) == EXIT_FAILURE);
/*Cas livre déjà emprunté*/
/*Suppression des emprunts*/
CHECK(chargementEmprunts(biblio, &emprunts, 0) == EXIT_SUCCESS);
file = fmemopen(buffer, 1024, "w");
afficherEmprunts(emprunts, file);
fclose(file);
CHECK(!strcmp(buffer, resultatEmpruntsSuppr));
strcpy(buffer, "");
/*Suppression des emprunts*/
//printf("%s\n", buffer);
//printf("%s\n", resultat);
//printf("%d %d\n", strlen(buffer), strlen(resultat));
CHECK(!strcmp(buffer, resultat));
/*Affichage des emprunts inférieur à une date donnée*/
file = fmemopen(buffer, 1024, "w");
afficherEmpruntsParDate(emprunts, file);
fclose(file);
CHECK(!strcmp(buffer, resultatEmpruntsParDate));
strcpy(buffer, "");
/*Affichage des emprunts inférieur à une date donnée*/
libererEmprunts(emprunts);
libererBiblio(biblio);
/********* Cas des emprunts *********/
}
END_TEST_GROUP(tp1)
/* -------------------------------------------------------------------- */
/* TESTS FIN Batterie de tests */
/* TESTS FIN Jeux de tests */
/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
/* main Programme principal */
/* */
/* principe: Créer le menu et lance les tests */
/* */
/* En entrée: argc : taille du tableau argv */
/* argv : tableau des arguments du programme */
/* */
......@@ -61,33 +133,33 @@ int main(int argc, char* argv[])
puts("--------------------- MENU --------------------------");
puts("1) Ajouter les emprunts enregistrés");
puts("2) Supprimer les emprunts enregistrées");
puts("2) Supprimer les emprunts enregistrés");
puts("3) Afficher les emprunts par date");
puts("4) Lancer les tests");
puts("5) Quitter le programme");
puts("-----------------------------------------------------");
printf("Choix ?");
printf("Choix ?\t");
scanf("%d", &choix);
switch(choix) {
case 1:
puts("Chargement des emprunts...");
if (chargementEmprunts(&emprunts, 1) == EXIT_SUCCESS)
if (chargementEmprunts(biblio, &emprunts, 1) == EXIT_SUCCESS)
{
afficherEmprunts(emprunts);
afficherEmprunts(emprunts, stdout);
}
break;
case 2:
puts("Suppression des emprunts...");
if (chargementEmprunts(&emprunts, 0) == EXIT_SUCCESS)
if (chargementEmprunts(biblio, &emprunts, 0) == EXIT_SUCCESS)
{
afficherEmprunts(emprunts);
afficherEmprunts(emprunts, stdout);
}
break;
case 3:
puts("Affichage des emprunts par date...");
afficherEmpruntsParDate(emprunts);
afficherEmpruntsParDate(emprunts, stdout);
break;
case 4:
RUN_TEST_GROUP(tp1);
......
src/utils.c
+ 21
− 19
View file @ 42784244
......@@ -4,6 +4,8 @@
/* -------------------------------------------------------------------- */
/* sddalloc wrapper de gestion d'erreurs pour malloc */
/* */
/* principe: Retourne un malloc classique mais exit en cas d'erreur */
/* */
/* En entrée: size: taille à allouer */
/* */
/* En sortie: Un pointeur pointant vers la cellule allouée */
......
src/utils.h
+ 8
− 5
View file @ 42784244
#ifndef UTILS_H
#define UTILS_H
/* -------------------------------- */
/* Prototypes */
/* -------------------------------- */
void *sddalloc(size_t);
#endif
\ No newline at end of file
tp1.principe deleted 100644 → 0
+ 0
− 281
View file @ e041cffc
STRUCTURE DE DONNEES :
cellule_t :
date_deb : entier contenant la date de début de validité du message
date_fin : entier contenant la date de fin de validité du message
msg : chaîne de caractère contenant le contenu du message
suiv : pointeur vers la prochaine cellule de la liste
donnee_t : alias pour cellule_t*
donnee_t creerListe(){
On retourne une liste vide;
}
Lexique :
Aucun
---------------------------------------------------
cellule_t* creerCellule(int date_deb, int date_fin, char* msg)
{
On alloue une nouvelle cellule pour la liste
si l'adresse retournée est non NIL
On affecte date_deb au champ date_deb de la cellule
On affecte date_fin au champ date_fin de la cellule
On affecte msg au champ msg de la cellule
On affecte à NIL le champ suiv
fin si
on retourne la nouvelle cellule
}
Lexique :
date_deb : Date de début du message à insérer
date_fin : Date de fin du message à insérer
msg : Contenu du message à insérer
tmp : pointeur vers la nouvelle nouvellement allouée
---------------------------------------------------
cellule_t** recherchePrecedent(donnee_t* liste, cellule_t* cellule)
{
On affecte un pointeur courant sur le pointeur qui pointe sur la tête de la liste
On affecte un pointeur de pointeur précédent sur la liste
Tant que le pointeur courant est différent de NULL ET la date de début pointée par le pointeur courant est inférieur à la date de début de la cellule que l'on recherche le précédent ALORS
On fait pointer le pointeur précédent sur le pointeur suivant de la cellule courante
On fait pointer le pointeur courant sur sa cellule suivante
Fin Tant que
On retourne le pointeur précédent
}
Lexique :
liste : pointeur vers le début de la liste chaînée
cellule : pointeur vers la cellule dont on cherche le précédent
date_deb : Date de début d'un message
cour : pointeur courant
prec : pointeur de pointeur pointant sur le pointeur suivant de la cellule précédente à celle recherchée
---------------------------------------------------
void inserer(cellule_t* cellule, cellule_t** prec)
{
On fait pointer le pointeur suivant de cellule sur la cellule suivante celle pointé par le pointeur précédent
On fait pointer le pointeur suivant de la cellule pointée par le pointeur précédent vers la cellule insérée
}
Lexique :
cellule : pointeur vers la cellule que l'on ajoute
prec : pointeur de pointeur sur la cellule précédente où l'ajout doit être fait
---------------------------------------------------
int chargement(donnee_t* liste, char* fichier)
{
On ouvre le fichier en mode écriture
SI le fichier ne s'ouvre pas ALORS
On affiche "impossible d'ouvrir le fichier"
On affecte au code la valeur EXIT_FAILURE
SINON
On lit une première fois pour savoir si le fichier n'est pas vide
TANT QUE nous sommes pas à la fin du fichier ALORS
On lit la fin de la ligne qui correspond au message
SI le message contient en dernier caractère '\n' ALORS
On remplace le '\n' par '\0'
FSI
On crée une cellule temporaire avec les dates et le message lu
On insére cette celulle dans la liste chaînée
On lit la date de début et la date de fin
FIN TANT QUE
On affecte au code la valeur EXIT_SUCCESS
On ferme le fichier
FSI
On retourne le code
}
Lexique :
liste : pointeur sur la tête de liste chaînée
fichier : nom du fichier
flot : pointeur de fichier
code : code d'erreur
date_deb : date de début du message chargé
date_fin : date de fin du message chargé
msg : contenu du message
tmp : pointeur sur une cellule temporaire
---------------------------------------------------
int sauvegarder(donnee_t liste)
{
On fait pointer le pointeur de cellule temporaire sur la tête de liste
On ouvre le fichier en mode écriture
SI le fichier ne s'est pas ouvert correctement ALORS
On affiche "Impossible d'ouvrir le fichier"
On affecte à code la valeur EXIT_FAILURE
SINON
TANT QUE le pointeur temporaire de cellule n'est pas arrivé à la fin de la liste ALORS
Ecrire dans le fichier la date de début, la date de fin et le msg de la cellule pointé par le pointeur temporaire
On fait pointer le pointeur temporaire sur la cellule suivante
FIN TANT QUE
On affecte à code la valeur EXIT_SUCCESS
FSI
On ferme le fichier
On retourne le code
}
Lexique :
liste : pointeur sur la tête de liste
tmp : pointeur temporaire qui parcourt toute la liste chaînée
flot : pointeur de fichier
code : code d'erreur
---------------------------------------------------
void afficherNonExpire(donnee_t liste)
{
On fait pointer le pointeur temporaire sur la tête de liste
On affecte à la variable now la date du jour
TANT QUE le pointeur temporaire n'a pas parcouru toute la liste ALORS
SI la date de fin pointé par le pointeur temporaire est supérieur à la date du jour ALORS
On affiche les dates et le message contenu par la cellule pointé par le pointeur temporaire
FSI
On fait pointer le pointeur temporaire sur la cellule suivante
FIN TANT QUE
}
Lexique :
liste : pointeur sur la tête de liste
tmp : pointeur temporaire parcourant la liste
now : entier représentant la date du jour
---------------------------------------------------
void afficherListe(donnee_t liste)
{
On fait pointer le pointeur temporaire sur la tête de liste
TANT QUE le pointeur tmp n'a pas parcouru toute la liste FAIRE
On affiche les date du message pointé par le pointeur temporaire et le message
Le pointeur temporaire pointe sur le message suivant
FIN TANT QUE
}
Lexique :
liste : pointeur sur la tête de liste
tmp : pointeur parcourant toute la liste
---------------------------------------------------
void supprimer(cellule_t* cellule, cellule_t** prec)
{
On fait pointer le pointeur cellule sur son élément suivant
On supprime de la mémoire l'élément précédent de celui pointé par cellule
On fait pointer le pointeur de pointeur précédent sur l'élément pointé par cellule
}
Lexique :
cellule : pointeur sur la cellule à supprimer
prec : pointeur de pointeur sur l'élément précédent pointé par cellule
---------------------------------------------------
void supprimerExpire(donnee_t* liste)
{
On fait pointer le pointeur temporaire sur le pointeur liste
On fait pointer le pointeur de pointeur précédent sur la tête de liste
On affecte à la variable now la date du jour
TANT QUE le pointeur temporaire n'a pas parcouru toute la liste FAIRE
SI la date de fin du message pointé par le pointeur temporaire est inférieur à la date du jour ALORS
On supprime le message
On fait pointer le pointeur temporaire sur le prochain message à vérifier
SINON
On fait pointer le pointeur précédent sur l'adresse du pointeur suivant pointé par le pointeur temporaire
On fait pointer le pointeur temporaire sur le message suivant à celui qu'il pointe
FSI
FIN TANT QUE
}
Lexique :
liste : pointeur de pointeur sur la tête de liste
tmp : pointeur temporaire qui parcourt la liste
prec : pointeur de pointeur sur l'élément précédent à l'élément pointé par le pointeur temporaire
now : entier représentant la date du jour
---------------------------------------------------
void changerDate(donnee_t* liste, int ancienne, int nouvelle)
{
On fait pointer le pointeur temporaire sur la tête de liste
On fait pointer le pointeur de pointeur précédent sur le pointeur pointant sur la tête de liste
TANT QUE le pointeur temporaire n'a pas parcourut toute la liste FAIRE
SI la date de début du message pointé par le pointeur temporaire est égal à la date à remplacer ALORS
On fait pointer un nouveau pointeur sur une nouvelle cellule créée avec la nouvelle date
On insére cette cellule dans la liste
On supprime l'ancienne cellule avec la date recherchée
On fait pointer le pointeur temporaire sur l'élément suivant à observer
SINON
On affecte au pointeur précédent l'adresse du pointeur suivant de la celulle pointé par le pointeur temporaire
On fait pointer le pointeur temporaire sur la cellule suivante
FSI
FIN TANT QUE
}
Lexique :
liste : pointeur de pointeur sur la tête de liste
ancienne : entier représentant la date à remplacer
nouvelle : entier représentant la nouvelle date
tmp : pointeur temporaire parcourant la liste
prec : pointeur pointeur sur la cellule précédente à celle pointé par le pointeur temporaire
nouv : pointeur sur la nouvelle cellule créée
---------------------------------------------------
int substring(char *chaine, char *motif)
{
On affecte à n le nombre de caractères présent dans le motif
On affecte à res la valeur 0
TANT QUE la partie de la chaîne observée n'est pas vide ET res est égale à 0 FAIRE
SI la partie de la chaîne observée contient le motif ALORS
On affecte à res la valeur 1
FSI
FIN TANT QUE
On retourne le résultat res
}
Lexique :
chaine : tableau de caractères observé
motif : tableau de caractères contenant le motif qu'on recherche
n : entier représentant le nombre de caractères dans le motif
res : variable pouvant être 0 ou 1 (0 -> motif non trouvé 1 -> motif trouvé)
---------------------------------------------------
void afficherMotif(donnee_t liste, char *motif)
{
On fait pointer un pointeur temporaire sur la tête de liste
TANT QUE le pointeur temporaire n'a pas parcouru toute la liste FAIRE
SI dans un message on retrouve le motif ALORS
On affiche les dates et le message
FSI
FIN TANT QUE
}
Lexique :
liste : pointeur de pointeur sur la tête de liste
motif : chaîne de caractères correspondant au motif
tmp : pointeur parcourant la liste
---------------------------------------------------
void libererListe(donnee_t liste)
{
On fait pointer un pointeur courant sur la tête de liste
TANT QUE le pointeur courant n'a pas parcouru toute la liste ALORS
Le pointeur temporaire pointe sur la même cellule que pointe le pointeur courant
Le pointeur courant pointe sur la cellule suivante
On libére la cellule pointée par le pointeur temporaire
FIN TANT QUE
}
Lexique :
liste : pointeur de pointeur sur la tête de liste
cour : pointeur courant parcourant la liste
tmp : pointeur temporaire servant à libérer les cellules de la mémoire
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment