[C] avis extérieur sur le projet

Bonjour,

Voilà je souhaitait mettre mon projet en ligne, maintenant que la date limite des rendus est passée.
Cela servira au prochaines personnes, en espérant qu'elles ne fassent pas que "pomper".

Donc voilà le code, je remercie les personnes m'ayant parfois aidé sur le forum.

Si des personnes veulent laisser leur impressions sur le code, elles sont les bienvenues étant donné que je passe mon oral la semaine prochaine, ça me permettrait d'avoir un avis extérieur sur le projet.


#include<stdio.h>
#include<string.h>
#include<conio.h>
#include<iostream.h>
#include<time.h>
#include<stdlib.h>

#define T 10 // 10 numeros dans un telephone
#define N 30 // 30 lettres maximum dans un nom ou prenom
#define M 50 // 50 caracteres pour une adresse email
#define tailleSMS 160



//####################################################################################################

/**********************************La STRUCTURE Message***********************************************

variables: chaines : SMS[tailleSMS+1], date[150], horloge[128];
*/
//####################################################################################################
typedef struct Message{
char SMS[tailleSMS+1];
char date[150];
char horloge[128];
struct Message *suivant;
}Message;
///////////////////////////////////////////////////////////////////////////////////////////////////





//####################################################################################################

/**********************************La STRUCTURE Contact***********************************************

variables: chaines : numerotel[T+1], name[N+1], pren[N+1],adrmail[M+1];
*/
//####################################################################################################

//structure stockage contact (les données)
typedef struct {
char numerotel[T+1]; // on rajoute toujours +1 pour avoir la place pour le "\0"
char name[N+1], pren[N+1],adrmail[M+1];
Message *imbriquee;
}Contact;
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/**********************************La STRUCTURE fiche*************************************************

variables: Contact : UnContact : contient les informations (nom+prenom+tel+mail) d'un contact
pointeur de type fiche : p_suivant : pointe sur des jetons de type fiche
*/
//####################################################################################################

//structure liste chain?e (donnée + pointeur)
typedef struct fiche{
Contact UnContact;
fiche *p_suivant;
}fiche;
///////////////////////////////////////////////////////////////////////////////////////////////////





//####################################################################################################

/**********************************La fonction InsertionEnTete****************************************

variables: : pointeur de type Message : liste_SMS : pointe sur la tête d'une liste chainée de type Message (fonction propre au JALON3 uniquement)
chaines : SMS, date, horloge : ce sont les donnée du nouveau jeton de type Message
*/
//####################################################################################################
// cette fonction insert le nouvel SMS sur la tete de la liste chainée du contact choisit par l'utilisateur
void InsertionEnTete(Message **listeSMS,char *SMS,char *date, char *horloge)
{
int i=0,j=0,position=-1;

Message* nouveau=(Message*)malloc(sizeof(Message));
strcpy(nouveau->SMS,SMS);
strcpy(nouveau->date,date);
strcpy(nouveau->horloge,horloge);

if((*listeSMS)!=NULL)// si y'a deja des messages chainés
{
Message* pcourant=*listeSMS; // on cree deux pointeurs tous deux initialises sur la tete de pp_liste
Message* p_parcours=*listeSMS;
for(i=0;p_parcours!=NULL;i++)
{
if((strcmp(p_parcours->date,nouveau->date)<0) || (strcmp(p_parcours->date,nouveau->date)==0) && (strcmp(p_parcours->horloge,nouveau->horloge)<0)) //on "regarde" ou il faudra inserer le nouveau jeton (par exemple sur le 3 ieme parcouru etc)
position=i;
p_parcours=p_parcours->suivant; //pour cela nous devons parcourir la liste chainee
}
if (position>=0) // avec le if du desssus, on connais alors la position dans laquelle on doit realiser l'insertion
{
for(j=0;j<position;j++)
pcourant=pcourant->suivant; // on recherche la bonne place pour inserer le jeton
nouveau->suivant=pcourant->suivant; // une fois le jeton trouve, on fait "passer" la liste chainee par notre jeton
pcourant->suivant=nouveau;
}
else //sinon c'est deja trie
{
nouveau->suivant=*listeSMS;
*listeSMS=nouveau;
}
}
else
{
nouveau->suivant=(*listeSMS);
(*listeSMS)=nouveau;
}

}
///////////////////////////////////////////////////////////////////////////////////////////////////



//####################################################################################################

/**********************************La fonction Afficher_Ses_SMS***************************************

variables: : pointeur de type Message : tete : pointe sur la tête d'une liste chainée de type Message
courant : il sert à parcourir la liste chainée de type Message en vue d'ércire sur l'écran les SMS
entier : numero : indique le numero correspondant au message en vue que l'utilisateur affecte un numero au SMS qu'il souhaiterait supprimer
*/
//####################################################################################################
//cette fonction affiche tous les SMS du contact choisit par l'utilisateur
int Afficher_Ses_SMS(Message *tete)
{
Message *courant;
int numero=1;
system("cls");//affichage
printf("------------------ liste des sms -----------------\n\n");
for(courant=tete;courant!=NULL;courant=courant->suivant)//on change a chaque fois de jetonMessage
{
printf("%d\t%s\t%s\t%s\n",numero,courant->date,courant->horloge,courant->SMS);// on affiche tous ses SMS
numero++;// on affiche aussi le numero, cela servira pour que l'utilisateur choisisse leque des SMS supprimer, en entrant le numero au clavier
}
free(courant);// on libère le pointeur, qui ne nous sert plus ensuite.
return numero;// on retourne le numero, qui servira a connaitre plus-tard le SMS a supprimer
}
///////////////////////////////////////////////////////////////////////////////////////////////////



//####################################################################################################

/**********************************La fonction Recuperation_Donnes_numeroDuJeton**********************

variables: : pointeur de type fiche : p_liste : pointe sur la tête d'une liste chainée de type fiche
parcours : il sert à parcourir la liste chainée de type fiche jusqu'à trouver le contact qui nous intéresse (grace au numero).
entier : i : indique le numero correspondant au jeton dans lequel on vient récupérer les informations.
chaines : nom, prenom, tel : ces variables sont retournée en vue de connaitre ce qu'elles contiennent à la fin de cette fonction
*/
//####################################################################################################
//cette fonction s'occupe de récupérer les informations sur le contact gràce au numero du jeton équivalent(voir fonction du dessus).
void Recuperation_Donnes_numeroDuJeton(fiche *p_liste,int nombre_jeton,char *nom,char *prenom,char *tel)
{
if(p_liste!=NULL)// si c'est différent de null car sinon il n'y a personne
{
fiche *parcours=p_liste;//parcours pointe sur p_liste au début.
for(int i=0;(i<nombre_jeton && parcours->p_suivant!=NULL);parcours=parcours->p_suivant)// ne pas oublier le cas ou l'utilisateur entre un numéro trop élevé, cequi ferait bugger le programme.
i++;
strcpy(nom,parcours->UnContact.name);// meme s'il s'agit d'un void, on retourne 3 chaines par "référence" (nom + prenom+ tel).
strcpy(prenom,parcours->UnContact.pren);
strcpy(tel,parcours->UnContact.numerotel);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/**********************************La fonction Reecrire_les_SMS***************************************

variables: : pointeur de type fiche : p_liste : pointe sur la tête d'une liste chainée de type fiche (au début seulement)
Message : courant : il sert a parcourir la liste chainée des SMS d'un contact.
FILE : sert a pointer sur le fichier des SMS.
entier : debut : il sert a ne pas mettre le '\n' lors de la première ligne. On a préféré finir le fichier par un & sur la meme ligne plutot que sur une ligne différente. Ceci est dû à notre volonté d'utoriser les noms composés.
*/
//####################################################################################################
void Reecrire_les_SMS(fiche *p_liste,FILE *fichier)
{
Message *courant=p_liste->UnContact.imbriquee;
int debut=1;
for(p_liste;p_liste!=NULL;p_liste=p_liste->p_suivant) // on change de jeton de contact // REPERE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! REPERE
{
for(courant=p_liste->UnContact.imbriquee;courant!=NULL;courant=courant->suivant)// on change de sms
{
if(debut==1)
{
fprintf(fichier,"%s|%s|%s|%s|",p_liste->UnContact.numerotel,courant->date,courant->horloge,courant->SMS);
debut=0;
}
else
fprintf(fichier,"\n%s|%s|%s|%s|",p_liste->UnContact.numerotel,courant->date,courant->horloge,courant->SMS);
}
}
fprintf(fichier,"&");
}
///////////////////////////////////////////////////////////////////////////////////////////////////


//####################################################################################################

/**********************************La fonction supprETOU*********************************************

variables: chaines : tampon : elle recoit une chaine du main et retourne vers le main une fois passée en maj
*/
//####################################################################################################
char *supprETOU(char *texte) // supprime x dans la chaine
{
int p,i;
for(i=0;texte[i]!='\0';i++)
{
if (texte[i]=='|' || texte[i]=='&') // si c'est un & ou un |
{
for(p=i;texte[p]!=0;p++)
texte[p]=texte[p+1];
}
}
return texte;
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/**********************************La fonction majuscules*********************************************

variables: chaines : tampon : elle recoit une chaine du main et retourne vers le main une fois passée en maj
*/
//####################################################################################################
char *majuscules(char *tampon)
{
for (int i=0;i<strlen(tampon);i++) // pour mettre en majuscule le nom en entier
{
tampon[i]=toupper(tampon[i]); // pour mettre en majuscule lettre par lettre
}
return tampon; // on retourne la chaine de caractères
}
///////////////////////////////////////////////////////////////////////////////////////////////////



//####################################################################################################

/**********************************La fonction renvoie_chaine*****************************************

variables: chaines : tampon : chaine passée en argument.
char : caractère : lettre dans le txt.
entier : i : place du caractère dans la chaine.
*/
//####################################################################################################
char *renvoie_chaine(char caractere,char *tampon,FILE *repertoire,int i)
{
caractere=fgetc(repertoire);
while (caractere!='|')
{
tampon[i]=caractere;
i++;
caractere=fgetc(repertoire);
}
tampon[i]='\0'; // attention au dernier caractère du fgetc !
i=0; // on prépare pour la prochiane chaine
return tampon;
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/**********************************La fonction lecture_champs*****************************************

variables: chaines : numtel,nom,prenom,email : information sur la ligne du txt
char : caractère : lettre dans le txt.
entier : i : place du caractère dans la chaine.
taille_totale : pour connaitre la position à pointer dans le fichier on aura besoin du nombre d'octet (ou de bit je ne sais plus) auquel on aimerai faire pointer le curseur de lecture fgetc
pointeur de type FILE : sur le fichier du repertoire
*/
//####################################################################################################
int lecture_champs(char *numtel,char *nom,char *prenom,char *email,int taille_totale,char *fichier)
{
char tampon[tailleSMS+1],caractere='0';
int i=0,attention;
FILE *repertoire=fopen(fichier,"r");
if (repertoire)
{
attention=fscanf(repertoire,"%s",tampon);
if(attention!=EOF && tampon[0]!='&')
{
fseek(repertoire,taille_totale,0);
strcpy(numtel,renvoie_chaine(caractere,tampon,repertoire,i));strcpy(tampon,"");
strcpy(nom,renvoie_chaine(caractere,tampon,repertoire,i));strcpy(tampon,"");
strcpy(prenom,renvoie_chaine(caractere,tampon,repertoire,i));strcpy(tampon,"");
strcpy(email,renvoie_chaine(caractere,tampon,repertoire,i));strcpy(tampon,"");
caractere=fgetc(repertoire);
} // et oui, peut être sommes nous en fin de fichier ??? ==> à tester
fclose(repertoire);
}
else
taille_totale=-9; // -9 + 6 = -3 : autre erreur possible (pas de txt)
taille_totale+=strlen(numtel)+strlen(nom)+strlen(prenom)+strlen(email)+6;
if(caractere=='&') // le & final
taille_totale=-1;
if(attention==EOF ||tampon[0]=='&') // si on est en EOF.
taille_totale=-2;
return taille_totale;
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/****************************La fonction verification_donne*******************************************

variables: chaines : tampon[M+1] : la taille est maxiamle pour accepter tout les types possibles (mail+nom+tel+prenom)
intitule_question : c'est le mot qui va changer entre les différentes questions a poser = mot clé de la question.
entières taille reçue : c'est la taille maximale admissible par la chaine en sortie de la fonction.
*/
//####################################################################################################
char *verification_donne(char *intitule_question,int taille_recue)
{
char tampon[M+1],lettre='0';
strcpy(tampon,""); // ceci est nécessaire car sinon on va sauter le telephone si on a une taille de 10 caractère dans le prénom tapé (le prénom tapé est l'étape précédente).
do
{
if (strcmp(intitule_question,"tel")==0) // si on lui demande le téléphone
{
while (strlen(tampon)!=10) // il faudra une taille de 10
{
printf("Entrer le %s de la personne ( < a %d caracteres ): ",intitule_question,taille_recue); // on stock les donnees dans les variables internes a la fonction
scanf("%10s",tampon);fflush(stdin); // on ne prend que les 10 premiers caractères tapéss e le reste on l'efface.
}
}
else
{
printf("Entrer le %s de la personne ( < a %d caracteres ):",intitule_question,taille_recue); // on stock les donnees dans les variables internes a la fonction
fgets(tampon,taille_recue+1,stdin);tampon[strlen(tampon)-1]='\0';fflush(stdin); // on met ça dans une taille de 50, le reste on effacera.
}
}
while(strlen(tampon)>=(taille_recue+1)); // petit rappel : on vient de passer par le "chemin" différent du tel (attention pour le moment la taille est de 50 !!!! alors que la taille sera soit de 30 (nom + prenom) ou 50 mail) donc on bouclera seulement lorsque ta taille correspondra.
fflush(stdin); // on efface la mémoire clavier pour éviter les plantages si on revient dans le main ( par exemple dernier chiffre tapé 3, on partira dans ajouter un contact.)
strcpy(tampon,supprETOU(tampon));
if(strcmp(intitule_question,"mail")!=0) // on met en majuscules tout sauf les mails (pas d'importance pour le tel)
return majuscules(tampon); // on retourne la chaine
else
return tampon;
}
///////////////////////////////////////////////////////////////////////////////////////////////////



//####################################################################################################

/********************************La fonction creation_jeton*******************************************

variables: chaines : numero[T+1], nom[N+1], prenom[N+1], mail[M+1] : variables d'entrées de la fonction.
pointeur de type fiche : pointeur : gràce à ce pointeur on va mettre les informations du contact dans une variable de type fiche et Contact plus exactement.
*/
//####################################################################################################
void creation_jeton(fiche *pointeur,char numero[T+1],char nom[N+1],char prenom[N+1],char mail[M+1])
{
strcpy(pointeur->UnContact.numerotel,numero); // cette fonction copie les variables internes aux fonctions dans un jeton.
strcpy(pointeur->UnContact.name,nom);
strcpy(pointeur->UnContact.pren,prenom);
strcpy(pointeur->UnContact.adrmail,mail);
}
///////////////////////////////////////////////////////////////////////////////////////////////////



//####################################################################################################

/******************************La fonction contact_deja_present***************************************

variables: chaines : nouveautel : variable d'entrée de la fonction, c'est le tépléphone que l'utilisateur vient d'entrer.
pointeur de type pointeur de fiche : pp_liste : gràce à ce pointeur on va connaitre la liste chainée
fiche: ce pointeur va servir a parcourir la liste chainée sans toucher à pp_liste, notre pointeur de référence pour connaitre la tête de lecture
entiers : fin=0 : si fin passe a 1, on arretera les recherches (1 contact possède le téléphone ou fin de liste chainée)
r : si r vaut 1, c'est qu'un contact possède déja ce téléphone. On retourne r vers une autre fonction, c'est le résultat de l'apel qui vaut 0 ou 1.
*/
//####################################################################################################

// Lorsqu'on ajoute ou modifie un contact, il ne faut pas qu'au final 2 contacts aient le meme numero de telephone. Elle va donc parcourir toute la liste chainee pour regarder si un contact n'a pas deja ce numero
int contact_deja_present(char *nouveautel,fiche **pp_liste)
{
int fin=0,r=0;
fiche *ptr=*pp_liste; // le pointeur ptr est le pointeur qui va parcourir la liste chainee pp_liste, on ne va pas travailler avec pp_liste mais avec ptr pour ne pas faire de changement sur le pointeur de tete (pp_liste)
while(fin==0) //on cherche si la personne n'est pas deja dans l'agenda
{
if(ptr==NULL) //si la liste est vide, on peut pas la parcourir donc en faisant fin=1 on quitte la boucle while
fin=1;
else
{
if (strcmp(nouveautel,(*ptr).UnContact.numerotel)==0) // si on a le meme telephone, compa renvoie 1 donc on a fin =1 et on quitte la boucle
{
r=1;
fin=1;
}
else // sinon (si r=0) = (si on a pas encore trouve le meme numero dans la liste chainee)
{
if((*ptr).p_suivant==0) // si on est sur le dernier jeton alors on doit s'arreter la sinon beug
fin=1;
ptr=(*ptr).p_suivant; // sinon c'est qu'il y a encore des jetons a etudier
}
}
}
return r; // on retourne r a la fonction ajouter contact.
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/************************************La fonction afficher*********************************************

variables: char : touche : l'utilisateur devra faire un echap pour revenir vers le Menu Principal
pointeur de type fiche : pp_liste : gràce à ce pointeur on va connaitre la liste chainée
ptr : ce pointeur va servir a parcourir la liste chainée sans toucher à p_liste, notre pointeur de référence pour connaitre la tête de lecture
entiers : fin=0 : si fin passe a 1, on arretera les recherches (fin de liste chainée).
repertoire : 0 si pas de répertoire et 1 sinon.
*/
//####################################################################################################

// fonction afficher qui affiche la liste de tous les jetons
void afficher(fiche *p_liste,int choix_utilisation)
{
int fin=0,nombre=0;
char touche='0',repertoire=0;
fiche *ptr=p_liste; // un pointeur de type fiche qui pointe sur la tete de la liste chainee
system("cls");
printf("------------------ liste des contact -----------------\n\n");
if(p_liste==NULL)
{
fin=1;
}
else// si la liste n'est pas vide
{
repertoire=1;
while(fin==0)
{
printf("%d\t%s %s\n\tTelephone : %s\tE-mail : %s\n",nombre,(*ptr).UnContact.name,(*ptr).UnContact.pren,(*ptr).UnContact.numerotel,(*ptr).UnContact.adrmail); // on affiche le jeton
if((*ptr).p_suivant==0) // si le pointeur p_suivant de la fiche est null (si on se trouve dans le dernier jeton de la liste)
fin=1;
ptr=(*ptr).p_suivant; //on passe a la fiche suivante
nombre++;
}
free(ptr);
}
if(repertoire==0 && choix_utilisation==2)
printf("ERREUR : Repertoire vide\n");
if(choix_utilisation!=6)
printf("\nECHAP : revenir au Menu du telephone");
if(choix_utilisation==1)
{
while(touche!=27)
{
if (kbhit()) // pour ressortir il faudra touche=27
touche=getch();
}
}
}


//####################################################################################################

/***********************************La fonction ecrire_fichier****************************************

variables: char : touche : l'utilisateur devra faire un echap pour revenir vers le Menu Principal
pointeur de type fiche : p_liste : gràce à ce pointeur on va connaitre la liste chainée
ptr : ce pointeur va servir a parcourir la liste chainée sans toucher à p_liste, notre pointeur de référence pour connaitre la tête de lecture
entiers : fin=0 : si fin passe a 1, on arretera les recherches (fin de liste chainée).
FILE : Repertoire : ce pointeur pointe sur un fichier (Repertoire.txt).
*/
//####################################################################################################

// fonction ecrire_fichier qui écrit dans le repertoire txt ce qu'on a modifiés dans la liste chainée
void ecrire_fichier(fiche *p_liste)
{
int fin=0;
char touche='0';
fiche *ptr=p_liste;; // un pointeur de type fiche qui pointe sur la tete de la liste chainee

FILE* Repertoire = NULL;
Repertoire=fopen("Repertoire.txt","w+"); // si on veut ecrire dans le txt apres avoir tout efface
if(p_liste==NULL)
{
printf("ERREUR : Repertoire vide\n\nECHAP : revenir au Menu du telephone");
fin=1;
}
while(fin==0) // si la liste n'est pas vide
{
if (Repertoire)
{
fprintf(Repertoire,"%s|%s|%s|%s|",(*ptr).UnContact.numerotel,(*ptr).UnContact.name,(*ptr).UnContact.pren,(*ptr).UnContact.adrmail); // on ?crit
}
if((*ptr).p_suivant==0)
{
fin=1; //si on est au bout de la liste chainée, il faudra s'arreter
fprintf(Repertoire,"&");
}
else
fprintf(Repertoire,"\n");
ptr=(*ptr).p_suivant; // le pointeur ptr pointe sur le p_suivant de sa fiche (a la fin il pointera donc sur null)
}
fprintf(Repertoire,"&");
fclose(Repertoire); // on referme le fichier

}
///////////////////////////////////////////////////////////////////////////////////////////////////



//######################################################################################################

/***********************************La fonction trier_1erelettre****************************************

variables: char : touche : l'utilisateur devra faire un echap pour revenir vers le Menu Principal
lettre : c'est un des arguments de la fonction qui correspond à la 1ère lettre du nom tapé par l'utilisateur
chaine : nom_tape : c'est le nom tapé par l'utilisateur.
pointeur de type fiche : p_liste : gràce à ce pointeur on va connaitre la liste chainée
pointeur_de_tri : ce pointeur va servir a parcourir la liste chainée sans toucher à p_liste, notre pointeur de référence pour connaitre la tête de lecture
entiers : presence_contact : compte le nombre de contacts présents dans le répertoire, on renvoie cette variable
nbpassages : pour éviter d'avoir des cls a chaque boucles
fermeture : si fermeture passe a 1, on arretera les recherches (fin de liste chainée).
choix_utilisation : Important : cette fonction a 2 roles : si choix_utilisation=2, on affiche par 1ère lettre si choix_utilisation=5, on affichera par nom entier exacte.
*/
//######################################################################################################

//recherche par premiere lettre (2 cas d'utilisation !!!!!! (cas 1 elle imprime à l'écran les contacts commençant par une lettre choisie, cas 2 elle imprime à l'écran les conatcts commenant par le nom choisit
int trier_1erelettre(fiche *p_liste,char lettre,int choix_utilisation,char *nom_tape)
{
fiche *pointeur_de_tri;
pointeur_de_tri=p_liste; // le pointeur de tri va parcourir la liste, on l'initialise donc par la tete(p_liste)
int presence_contact=0,nbpassages=0,fermeture=0;
char touche='0'; // on initialise par une valeur neutre
if(choix_utilisation==2)
{
system("cls"); // on efface la premiere phrase demandant la lettre tapee par l'utilisateur
printf("----------- liste des contact (1ere lettre) -----------\n\n");
}
else
printf("\n");
while (touche!=27)
{
if (p_liste!=NULL)
{
while(fermeture!=1)
{
if(lettre==*pointeur_de_tri->UnContact.name && choix_utilisation==2)
{
printf("%s %s %s %s\n",(*pointeur_de_tri).UnContact.numerotel,(*pointeur_de_tri).UnContact.name,(*pointeur_de_tri).UnContact.pren,(*pointeur_de_tri).UnContact.adrmail); // on regarde si le nom commence par la lettre sinon on affiche le jeton
presence_contact=1;
}
if((strcmp(nom_tape,pointeur_de_tri->UnContact.name)==0) && choix_utilisation==5) // on regarde si le nom du jeton correspond au nom saisi
{
printf("%s %s %s %s\n",(*pointeur_de_tri).UnContact.numerotel,(*pointeur_de_tri).UnContact.name,(*pointeur_de_tri).UnContact.pren,(*pointeur_de_tri).UnContact.adrmail); // affichage des jetons dont le nom correspond
presence_contact++;
}
if((*pointeur_de_tri).p_suivant!=NULL) // si le pointeur suivant du jeton actuel est different de NULL on change de jeton
pointeur_de_tri=(*pointeur_de_tri).p_suivant;
else // sinon cela signifie que l'on est sur le dernier jeton, on ferme
fermeture=1; // on ferme la boucle quand on arrive a la fin de la liste chainee
}
if (presence_contact==0 && nbpassages==0 && choix_utilisation==2) // ce message doit s'afficher seulement au passage de la 1ere boucle pour eviter une reecriture a chaque passage
printf("ERREUR : Aucuns contacts commencants par %c \n\nECHAP : revenir au Menu du telephone",lettre);
if (presence_contact==1 && nbpassages==0 && choix_utilisation==2) // ce message doit s'afficher seulement au passage de la 1ere boucle pour eviter une reecriture a chaque passage
printf("\nECHAP : revenir au Menu du telephone\n");
}
else
{
if(nbpassages==0 && choix_utilisation==2)
printf("ERREUR, repertoire vide\n\nECHAP : revenir au Menu du telephone");
}
nbpassages++;
if (kbhit())
touche=getch(); // pour sortir de la boucle avec la touche echap (code ascii 27)
if(choix_utilisation==5)
{
touche=27;
printf("\n");
}
}
free(pointeur_de_tri);
return presence_contact;
}
///////////////////////////////////////////////////////////////////////////////////////////////////





//###############################################################################################################

/****************************************La fonction trier_alphabetique*******************************************

variables: chaines : nom,prenom,email,numtel : informations sur le contact
pointeur de type pointeur de type fiche : pp_liste : gràce à ce pointeur on va connaitre la liste chainée
fiche : nouveau : ce pointeur pointera sur le jeton en cours de création
p_parcours : ce pointeur va servir a parcourir la liste chainée sans toucher à p_liste, notre pointeur de référence pour connaitre la tête de lecture. ON va regarder ou sera le bon endroit pour venir insérer
p-courant : maintenant on sait ou insérer, on va le faire gràace a ce pointeur.
entiers : compteur : on connait le nombre de jeton qu'on devra parcourir.
i,j : simples variables d'incrémentation
position : c'est le numéro du jeton ou on ira insérer.
taille_totale : c'est le nombre d'octets qu'on devra aller chercher avec le fseek de la fonction lecture_champs
fin : variables qui sert a ne pas faire bugger le programme, on arretera fgetc de la fonction renvoie_chaine avant la fin du fichier
*/
//################################################################################################################

//fonction tri alphabetique par tri par insertion
void trier_alphabetique (fiche** pp_liste)
{
int compteur=1,i=0,j=0,position=-1,taille_totale=0,fin=0,piege=0;
char nom[N+1],prenom[N+1],email[M+1],numtel[T+1];
if(pp_liste!=NULL)
{
*pp_liste=NULL;
taille_totale=lecture_champs(numtel,nom,prenom,email,taille_totale,"Repertoire.txt");
if (taille_totale!=-2 && taille_totale!=-3)// s'il y a quelque chose, on crée le 1er jeton !!
{
fiche* nouveau=(fiche*)malloc(sizeof(fiche));// si il y a des ecritures dans le fichier on cree le jeton
creation_jeton(nouveau,numtel,nom,prenom,email); // on le remplit
nouveau->p_suivant=*pp_liste; // on lui met l'adresse de pp_liste (NULL)
*pp_liste=nouveau; // puis pp_liste est une liste "chainee" d'un element
if(taille_totale==-1)// attention, on risque de se faire piéger en mettant créant des donnée non remplies lorsqu'on ira dans la boucle (décalage de 1 cran entre elcture des donnée et création)
piege=1;
}
strcpy(numtel,"");strcpy(email,"");strcpy(prenom,"");strcpy(nom,""); // on efface tout pour pas avoir des résidus de caractères
if(taille_totale!=-1 && taille_totale!=-2 && taille_totale!=-3)
taille_totale=lecture_champs(numtel,nom,prenom,email,taille_totale,"Repertoire.txt"); // 2 ieme lecture
if (piege!=1 && taille_totale!=-2 && taille_totale!=-3)
{
while (fin!=1)
{
fiche* nouveau=(fiche*)malloc(sizeof(fiche)); // on cree a nouveau un jeton
creation_jeton(nouveau,numtel,nom,prenom,email); // on entre les donnees
fiche* pcourant=*pp_liste; // on cree deux pointeurs tous deux initialises sur la tete de pp_liste
fiche* p_parcours=*pp_liste;
for(i=0;i<compteur;i++)
{
if(strcmp(p_parcours->UnContact.name,nouveau->UnContact.name)<0) //on "regarde" ou il faudra inserer le nouveau jeton (par exemple sur le 3 ieme parcouru etc)
position=i;
p_parcours=p_parcours->p_suivant; //pour cela nous devons parcourir la liste chainee
}
if (position>=0) // avec le if du desssus, on connais alors la position dans laquelle on doit realiser l'insertion
{
for(j=0;j<position;j++)
pcourant=pcourant->p_suivant; // on recherche la bonne place pour inserer le jeton
nouveau->p_suivant=pcourant->p_suivant; // une fois le jeton trouve, on fait "passer" la liste chainee par notre jeton
pcourant->p_suivant=nouveau;
}
else //sinon c'est deja trie
{
nouveau->p_suivant=*pp_liste;
*pp_liste=nouveau;
}
position=-1;
strcpy(numtel,"");strcpy(email,"");strcpy(prenom,"");strcpy(nom,""); // on réefface ces données
if(taille_totale!=-1 && taille_totale!=-2)
taille_totale=lecture_champs(numtel,nom,prenom,email,taille_totale,"Repertoire.txt");// on prépare le prochain passage dans le while
else
fin=1;
compteur++; // pour compter le nombre de contacts, on pourra faire un return compteur si besoin futur
}
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/*********************************La fonction supprimer_contact***************************************

variables: chaines : nom_suppr, prenom_suppr, tel_suppr : informations sur le contact à supprimer
char : touchette : pour que l'utilisateur revienne vers le Menu Principal par echap.
pointeur de type fiche : p_liste : gràce à ce pointeur on va connaitre la liste chainée
p-courant : va parcourir la liste chainée
FILE : Repertoire : ce pointeur pointe sur un fichier (Repertoire.txt).
entiers : fin=0 : si fin passe a 1, on arretera les recherches (fin de liste chainée).
presence_contact : pour connaitre si il y a un contact correspondant à la recherche effectuée
nombre_contact : pour connaitre le nombre de contats portant le nm indiqué par l'utilisateur
entrer : variable qui prend les valeures 0 ou 1 si on doit mettre le "\n" à la fin de la chaine.
*/
//####################################################################################################
void supprimer_contact(fiche *p_liste,char *nom_suppr,char *prenom_suppr,char *tel_suppr,int nombre_contact)
{
int fin=0,presence_contact=0; // initialisations
char touchette='0',entrer=0;
fiche *p_courant=p_liste;
if (p_liste!=NULL) // si le repertoire s'ouvre on marque a la suite de tout ce qui y est marque ce qui nous interesse.
{
FILE* Repertoire = NULL; // il faut ouvrir le fichier: création d'un pointeur de type FILE qui "ouvrira" le fichier
Repertoire=fopen("Repertoire.txt","w+");
if (Repertoire)
{
while (fin==0)
{
if ((strcmp(nom_suppr,(*p_courant).UnContact.name)!=0)&&(nombre_contact==0) || (strcmp(prenom_suppr,(*p_courant).UnContact.pren)!=0)&&(nombre_contact==0) || (strcmp(tel_suppr,(*p_courant).UnContact.numerotel)!=0)&&(nombre_contact==0) || (nombre_contact==1)&&(strcmp(nom_suppr,(*p_courant).UnContact.name)!=0) || (nombre_contact>1)&&(strcmp(tel_suppr,(*p_courant).UnContact.numerotel)!=0)) // si le prenom OU le nom OU le telephone ne sont pas bons (en clair si il existe une différence), il ecrit les autres contacts
{
fprintf(Repertoire,"%s|%s|%s|%s|",(*p_courant).UnContact.numerotel,(*p_courant).UnContact.name,(*p_courant).UnContact.pren,(*p_courant).UnContact.adrmail);// on regarde si le nom commence par la lettre et sinon on affiche le jeton
entrer=1;
}
else
{
entrer=0;
presence_contact=1;// sinon on vient de trouver le contact écrit par l'utilisateur
}
if ((*p_courant).p_suivant!=NULL) // si le pointeur psuivant du jeton actuel est différent de NULL, ça sigifie qu'il y a un jeton derrière
{
p_courant=(*p_courant).p_suivant; // donc on peut y aller
if (entrer==1 && (strcmp(nom_suppr,(*p_courant).UnContact.name)!=0)&&(nombre_contact==0) || (strcmp(prenom_suppr,(*p_courant).UnContact.pren)!=0)&&(nombre_contact==0) || (strcmp(tel_suppr,(*p_courant).UnContact.numerotel)!=0)&&(nombre_contact==0) || (nombre_contact==1)&&(strcmp(nom_suppr,(*p_courant).UnContact.name)!=0) || (nombre_contact>1)&&(strcmp(tel_suppr,(*p_courant).UnContact.numerotel)!=0))
fprintf(Repertoire,"\n");
}
else
{
fin=1; // sinon on est a la fin de la liste chainée
fprintf(Repertoire,"&");
}
}
}
fclose(Repertoire); // on ferme le répertoire
}
system("cls"); // place à l'affichage
if (presence_contact==1)
printf("Contact supprime\n\nECHAP : revenir au Menu du telephone\n");
else
printf("ERREUR : Ce contact n'est pas present dans le repertoire\n\nEchap : Revenir au menu de telephone\n");
while (touchette!=27) // l'utilisateur tapera Echap pour revenir au menu principal
{
if(kbhit())
touchette=getch();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/**********************************La fonction modifier_contact***************************************

variables: chaines : nom_a_modifier, prenom_a_modifier, tel_a_modifier : informations sur le contact à modifier
nom,prenom,adressmail,tel : nouvelles informations sur le contact modifié
char : touche : pour que l'utilisateur revienne vers le Menu Principal par echap.
pointeur de type pointeur de type fiche : pp_liste : gràce à ce pointeur on va connaitre la liste chainée
fiche : pointeur_parcours : va parcourir la liste chainée
entiers : fermeture=0 : si fermeture passe a 1, on arretera les recherches (fin de liste chainée).
presence_contact : pour connaitre si il y a un contact correspondant à la recherche effectuée
r : résultat de l'appel de la fonction contact_deja_present (0 ou 1)
*/
//####################################################################################################
void modifier_contact(fiche **p_liste,char *nom_a_modifier,char *prenom_a_modifier,char *tel_a_modifier,int nombre_contact)
{
fiche *pointeur_parcours=*p_liste; // le pointeur de type fiche qui va parcourir la liste doit etre initialise par la tete
int fermeture=0,r,presence_contact=0;
char nom[N+1],prenom[N+1],adressmail[M+1],tel[T+1],touche='0'; // variables internes a la fonction
system("cls");
if(*p_liste!=NULL)
{
if(nombre_contact==0)
fermeture=1;
while(fermeture!=1)
{
if((nombre_contact>1)&&(strcmp(nom_a_modifier,pointeur_parcours->UnContact.name)==0 && (strcmp(tel_a_modifier,pointeur_parcours->UnContact.numerotel)==0)) || ((nombre_contact==1)&&(strcmp(nom_a_modifier,pointeur_parcours->UnContact.name)==0))) // si le prenom OU le nom ne sont pas bons, il ?crit les autres contacts) // si le nom est pr?sent
{
printf("-------------- Nouvelle Fiche --------------\n\n");
strcpy(nom,verification_donne("nom",N)); // on fait appel a ces fonctions pour s'assurer que l'utilisateur ne va pas entrer des donnees incorrectes
strcpy(prenom,verification_donne("prenom",N));
strcpy(tel,verification_donne("tel",T));
strcpy(adressmail,verification_donne("mail",M));
r=contact_deja_present(tel,p_liste); // on regarde si le telephone n'est pas deja dans la liste chain?e (si deja : 1 sinon 0)
if (r==1)
{
system("cls");
printf("Ce numero existe deja\n\nECHAP : revenir au Menu du telephone");
fermeture=1;
presence_contact=0;
}
else
{
creation_jeton(pointeur_parcours,tel,nom,prenom,adressmail);
fermeture=1;
presence_contact=1;
system("cls");
printf("Contact modifie\n\nECHAP : revenir au Menu du telephone");
}
}
if((*pointeur_parcours).p_suivant!=NULL) // si on est pas sur le dernier jeton on passe au suivant
pointeur_parcours=(*pointeur_parcours).p_suivant;
else
fermeture=1; // sinon on ferme
}
}
if (presence_contact==0)
printf("Erreur ce contact n'existe pas\n\nECHAP : revenir au Menu du telephone");
while(touche!=27)
{
if (kbhit())
touche=getch();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/******************************La fonction demande_suppr_ou_modif*************************************

variables: chaines : pointeur_nom, pointeur_prenom, pointeur_telephone : variable d'entrées de la fonction, qui correspeondent a des emplacement bien caractérisés das la mémoire, il ne sont pas remplis au début de l'appel
pointeur de type fiche : p_liste : gràce à ce pointeur on va connaitre la liste chainée
entiers : fermeture=0 : si fermeture passe a 1, on arretera les recherches (fin de liste chainée).
presence_contact : pour connaitre le nombre de contacts correspondant à la recherche effectuée
*/
//####################################################################################################
int demande_suppr_ou_modif(fiche *p_liste,char *pointeur_nom,char *pointeur_prenom,char *pointeur_telephone,char *role)
{
int presence_contact=0;
system("cls");
printf("------------------%s un contact------------------\n\n",role);
strcpy(pointeur_nom,verification_donne("nom",N)); // on fait appel a ces fonctions pour s'assurer que l'utilisateur ne va pas entrer des donnees incorrectes
trier_alphabetique(&p_liste);
presence_contact=trier_1erelettre(p_liste,pointeur_nom[0],5,pointeur_nom);
if (presence_contact>1) // si plus d'un contact portant ce nom, on demande le prenom
{
strcpy(pointeur_telephone,verification_donne("tel",T)); // on fait appel a ces fonction pour s'assurer que l'utilisateur ne va pas entrer des donnees incorrectes
} // on retourne le nombre de contacts.
if (strcmp(role,"ecrire un SMS a ")==0 && presence_contact==1)
{
for(p_liste;p_liste!=NULL;p_liste=p_liste->p_suivant)
{
if (strcmp(pointeur_nom,p_liste->UnContact.name)==0)
strcpy(pointeur_telephone,p_liste->UnContact.numerotel);
}
}
return presence_contact;
}
///////////////////////////////////////////////////////////////////////////////////////////////////




//####################################################################################################

/************************************La fonction ajouter**********************************************

variables: chaines : nom, prenom, tel, adressmail : on va écrire les informations dans ces variables seulemnent après avoir été sur que l'utilisateur ne fasse pas bugger le programme
char: touche : pour que l'utilisateur revienne vers le Menu Principal par echap.
pointeur de type pointeur de type fiche : pp_liste : gràce à ce pointeur on va connaitre la liste chainée
fiche : nouveau : pointera sur le jeton qu'on crée.
entiers : fin=0 : si fin passe a 1, on arretera les recherches (fin de liste chainée).
resulatat_appel : résultat de l'appel de la fonction contact_deja_present (0 ou 1)
*/
//####################################################################################################

//fonction ajouter contact qui est utilisee dans le case 3 "ajouter un contact" du main
void ajouter(fiche **pp_liste)
{
char nom[N+1],prenom[N+1],adressmail[M+1],tel[T+1],touche='0'; // variables internes a la fonction
int fin=0,resultat_appel; // pointeur de type fiche (donnee + pointeur)
system("cls"); // affichage
printf("------------------ajouter un contact------------------\n\n");
strcpy(nom,verification_donne("nom",N)); // on fait appel a ces fonctions pour s'assurer que l'utilisateur ne va pas entrer des donnees incorrectes
strcpy(prenom,verification_donne("prenom",N));
strcpy(tel,verification_donne("tel",T));
strcpy(adressmail,verification_donne("mail",M)); // on fait appel a ces fonction pour s'assurer que l'utilisateur ne va pas entrer des donnees incorrectes
resultat_appel=contact_deja_present(tel,pp_liste); // on regarde si le telephone n'est pas deja dans la liste chainee (si deja : 1 sinon 0)
if(resultat_appel==0)
{
fiche* nouveau=(fiche*)malloc(sizeof(fiche)); // si il y a des ecritures dans le fichier on cree le jeton
creation_jeton(nouveau,tel,nom,prenom,adressmail); // on le remplit
nouveau->p_suivant=*pp_liste; // on lui met l'adresse de pp_liste (NULL)
*pp_liste=nouveau; // puis pp_liste est une liste "chainee" d'un element
ecrire_fichier(*pp_liste);
}
system("cls"); // on efface içi,hors de la boucle while de dessous, c'est plus joli
if(resultat_appel==1)
printf("Ce numero existe deja : Contact non ajoute\n\nECHAP : revenir au Menu du telephone");
else
printf("Contact ajoute\n\nECHAP : revenir au Menu du telephone");
while(touche!=27)
{
if(kbhit()) // comme ça avec un Echap on retournera vers le menu principal
touche=getch();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////



//####################################################################################################

/************************************La fonction EcrireSMS********************************************
variables: chaines : SMS, horloge, date : on va récupérer la date actuelle dans date et l'heure/minIsec dans horloge, SMS servira a stocker le SMS
char: touche : pour que l'utilisateur revienne vers le Menu Principal par echap.
pointeur de type pointeur de type fiche : p_courant : ce pointeur pointe non pas sur la tete de p_liste mais sur le contact dans lequel on souhaite écrire le SMS (voir fonction ci-dessous)
FILE : listeSMS : pointe sur le fichier .txt des SMS.
*/
//####################################################################################################
void EcrireSMS(char *nomSMS, char *prenomSMS,char *telSMS,char *mailSMS,fiche *p_courant,int nombre_contact,fiche *tete)
{
FILE* listeSMS = NULL;
char SMS[tailleSMS+1],horloge[128],date[150];
_tzset();_strtime(horloge);
time_t time_of_day; //valeur contenant le temps écoulé depuis le 01/01/1970
time_of_day = time( NULL ); //récupérer le temps passé
strftime(date,150,"%Y/%m/%d",localtime( &time_of_day ) ); //inscrire dans la chaîne buffer notre string telle que nous la voulons
fflush(stdin); // on libère le clavier, indispensable car sinon on sautera le fgets

listeSMS=fopen("SMS.txt","w+"); // on l'ouvre en mode réécriture.(plus besoin de faire des if(listeSMS) car il y aura création s'il n'existe pas).
system("cls"); // affichage
printf("Entrez votre SMS (160 caractères au maximun)\n");
fgets(SMS,tailleSMS+1,stdin);SMS[strlen(SMS)-1]='\0'; // on récupère 160 caractères +1 qui est l'\0', le reste sera ignoré.
strcpy(SMS,supprETOU(SMS)); // attention si l'utilisateur entre des | cela va arreter la lecture d'une chaine alors que normalement il ne faudrait pas, plus grave encore, on va renvoyer un offset qui ne comprend pas les caractères suivant pour le fseek, et à tous les coups on risque de faire bugger le getch. (ceci est dû a notre choix d'autoriser les noms composés)
InsertionEnTete(&p_courant->UnContact.imbriquee,SMS,date,horloge); // on vient insérer içi. (le p_courant pointe déja sur le bon contact grâce a la fonction précédente.) (uniquement dans le JALON3, pas dans le 4)
Reecrire_les_SMS(tete,listeSMS); // on lui passe la tete pour ne pas qu'il oublie tout les autes messages de p_liste
fclose(listeSMS); // on n'oublie pas de fermer ce fichier, car si on le réouvre autre-part on aura des pbs
}
///////////////////////////////////////////////////////////////////////////////////////////////////





//####################################################################################################

/************************************La fonction envoyerSMS********************************************
variables: char: touche : pour que l'utilisateur revienne vers le Menu Principal par echap.
pointeur de type pointeur de type fiche : p_courant : ce pointeur sert a parcourir la liste jusqu'à trouver le bon contact
p_liste : pointeur de tete de