[C] problèmes pointeur de chaines.

bonjour,

j'ai supprimé la signe ou j'ai mis
*pointeur_nom = 0; *pointeur_prenom = 0;
mais le compilateur me met la même chose, à savoir "canont convert char(*)(tailledelachaine) to char* for argument 2 to demande_suppr_ou_modif.

1) erreur lors de la compilation
2)rien de nouveau, le comilateur me dit la meme chose.
3) non il n'y avait pas de fautes de frappes c'est bien des ( ) mais la tailledelachaine c'est en faite 31 ( en faite j'ai fait une taille de 30 mais y'a le '\0'.

voilà voilà.

1) le compilateur affiche le meme message d'erreur avec toute la fonction en commentaire.
2) et bien il n'y a pas plus d'erreurs, mais je pense que le compilateur ne vas même pas jusque là ???

mais tu sait j'ai pensé à un truc mais ça me parait un peu compliqué pour ressortir une chaine.
Si on fait un pointeur de type char, qu'on fait pointer sur le 1er caractère de la chaine et qu'on fait un pointeur++, ça ira peut être vers la chaine. par contre ça signifie qu'on doit a chaque fois repasser par la fonction donc ce serait surement galère et surement que j'aurais un code pas très beau.
Qu'est ce que t'en pense, t'a déja vu un truc du genre ???

++

salut mahmah

tout d'abord merci de m'avoir accordé un si long message !!!!!!

c'est moi qui a perdu les pédales, j'ai oublié un "pas" dans le 2. il fallait dire il n'y a pas plus d'erreurs.
Il se passe toujours la meme chose.
Je tiendrait compte de ce que tu as dit pour les majuscules car j'ai en effet utilisé une variable tampon (au passage, le compil m'a annoncé un warning).

Donc pour récapituler, il se passe des problèmes dans les arguments ça c'est sur.

voilà sinon je suis en train de me poser des quetions quand à la raison du fait que char *chaine soit une chaine et pas en faite des pointeurs de caractères, utilisés un peu comme en comparaison avec des pointeurs de type int :

int tab[taille];
int *p_tab=&tab[0];
p_tab++;

voilà en gros tabula resa sur ce que je pensais des char.

Qu'est ce que vous en pensez les autres, pas seulement mahmah ????????????

a++

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

#define nbmaxcontacts 150
#define T 10 // 10 numéros dans un téléphone
#define N 30 // 30 lettres maximum dans un nom ou prenom
#define M 50 // 50 caractères pour une adresse email
#define tailleSMS 160




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

/**********************************LA STRUCTURE Contact********************************************/

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

//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];
}Contact;
///////////////////////////////////////////////////////////////////////////////////////////////////




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

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

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

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




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

/**********************************LA STRUCTURE SmS********************************************/

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

//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];
char SMS[tailleSMS], buffer[150], horloge[128];
}SmS;
///////////////////////////////////////////////////////////////////////////////////////////////////




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

/**********************************La STRUCTURE jeton_SMS*********************************************/

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

//structure liste chainée (donnée + pointeur)
typedef struct jeton_SMS{
SmS UnSMS;
jeton_SMS *p_suivant;
}jeton_SMS;
///////////////////////////////////////////////////////////////////////////////////////////////////


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

/**********************************LA fonction majuscules********************************************/

//####################################################################################################
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 la 1ère lettre
}
return tampon;
}
///////////////////////////////////////////////////////////////////////////////////////////////////



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

/****************************La STRUCTURE verification_donnée****************************************/

//####################################################################################################
char *verification_donne(char *intitule_question,int taille_recue)
{
char tampon[200];
int i=0;
do
{
if (strcmp(intitule_question,"tel")==0)
{
while (strlen(tampon)!=10)
{
printf("Entrer le %s de la personne ( < a %d caracteres ): ",intitule_question,taille_recue); // on stock les données dans les variables internes a la fonction
scanf("%s",tampon);fflush(stdin);
}
}
else
{
printf("Entrer le %s de la personne ( < a %d caracteres ): ",intitule_question,taille_recue); // on stock les données dans les variables internes a la fonction
scanf("%s",tampon);fflush(stdin);
}
}
while(strlen(tampon)>=(taille_recue+1));
if(strcmp(intitule_question,"mail")!=0)
majuscules(tampon);
return tampon;
}
///////////////////////////////////////////////////////////////////////////////////////////////////



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

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

//####################################################################################################
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);
strcpy(pointeur->UnContact.name,nom);
strcpy(pointeur->UnContact.pren,prenom);
strcpy(pointeur->UnContact.adrmail,mail);
}
///////////////////////////////////////////////////////////////////////////////////////////////////




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

/********************************La fonction creation_jetonSMS******************************************/

//####################################################################################################
void creation_jetonSMS(jeton_SMS *pointeur,char numero[T+1],char nom[N+1],char prenom[N+1],char mail[M+1],char buffer[150],char horloge[128],char SMS[tailleSMS])
{
strcpy(pointeur->UnSMS.numerotel,numero);
strcpy(pointeur->UnSMS.name,nom);
strcpy(pointeur->UnSMS.pren,prenom);
strcpy(pointeur->UnSMS.adrmail,mail);
strcpy(pointeur->UnSMS.buffer,buffer);
strcpy(pointeur->UnSMS.horloge,horloge);
strcpy(pointeur->UnSMS.SMS,SMS);
}
///////////////////////////////////////////////////////////////////////////////////////////////////





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

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

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

// Lorsqu'on ajoute ou modifie un contact, il ne faut pas qu'au final 2 contacts aient le meme numéro de phone. Elle va donc parcourir toute la liste chainée pour regarder si un contact n'a pas déja ce numéro
int contact_deja_present(char *nouveautel,fiche **pp_liste)
{
int fin=0,r=0;
fiche *ptr;

//initialisation

ptr=*pp_liste; // le pointeur ptr est le pointeur qui va parcourir la liste chainée pp_liste, on va pas travailler avec pp_liste mais avec ptr pour ne pas faire de changement sur le pointeur de tete (pp_liste)

//on cherche si la personne n'est pas déjà dans l'agenda

while(fin==0)
{
if(ptr==NULL) // déja 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 trouvé le meme numéro dans la liste chainée)
{
if((*ptr).p_suivant==0) // si on est sur le dernier jeton alors on doit s'arreter là sinon beug
fin=1;
ptr=(*ptr).p_suivant; // sinon c'est qu'il y a encore des jetons a étudier
}
}
}
return r; // on retourne r à la fonction ajouter contact.
}
///////////////////////////////////////////////////////////////////////////////////////////////////



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

/**********************************La fonction ajouter_contact***************************************/

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

//Cette fonction est utilisée dans la fonction ajouter (juste en dessous) lorsqu'on est dans le case 3 du menu principal: main->ajouter->ajouter_contact. Son but est d'ajouter le nouveau contact que l'utilisateur entre au fichier .txt
void ajouter_contact(char *tel,char *nom,char *prenom,char *email)
{
FILE* Repertoire = NULL;
Repertoire=fopen("Repertoire.txt","a+");
if (Repertoire) // si le répertoire s'ouvre on marque à la suite de tout ce qui y est marqué ce qui nous intéresse.
{
fprintf(Repertoire,"\n%s %s %s %s",tel,nom,prenom,email);
}
else // sinon ça s'ouvre pas.
printf("ERREUR : pas de fichier repertoire");
fclose(Repertoire);
}
///////////////////////////////////////////////////////////////////////////////////////////////////




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

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

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

//fonction ajouter contact qui est utilisée 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,i; // pointeur de type fiche (donnée + pointeur)
system("cls");
strcpy(nom,verification_donne("nom",N)); // on fait appel à ces fonction pour s'assurer que l'utilisateur ne va pas entrer des betises
strcpy(prenom,verification_donne("prenom",N));
strcpy(tel,verification_donne("tel",T));
strcpy(adressmail,verification_donne("mail",M)); // on fait appel à ces fonction pour s'assurer que l'utilisateur ne va pas entrer des betises
resultat_appel=contact_deja_present(tel,pp_liste); // on regarde si le telephone n'est pas déja quelquepart dans la liste chainée (si déja : 1 sinon 0)
if(resultat_appel==0)
ajouter_contact(tel,nom,prenom,adressmail); // appel de cette fonction qui va permettre de mettre le contact dans le répertoire.txt
while(touche!=27)
{
system("cls");
if(resultat_appel==1)
printf("Ce numero existe deja : Contact non ajoute\n\nECHAP : revenir au Menu du repertoire");
else
printf("Contact ajoute\n\nECHAP : revenir au Menu du repertoire");
if(kbhit())
touche=getch();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////



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

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

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

/*ATTENTION : fontion affichage OU écriture du nouveau txt : 1 pour afficher 2 : pour écrire
SI elle reçoit 1 dans choix, il s'agit d'un simple affichage de la liste chainée, si c'est 2, elle copie tout les données du pointeur dans le répertoire après y avoir tout effacé au préalable*/
void afficher(fiche *p_liste,int choix)
{
int fin=0;
char touche='0';
fiche *ptr; // un pointeur de type fiche qui pointe sur la tete de la liste chainée
ptr=p_liste;

switch(choix) // en gros içi on demande ce qu'on vient réellement faire dans cette fonction
{
case 1 :// si on veut afficher la liste chainée
{
while (touche!=27)
{
ptr=p_liste;
system("cls");
if(p_liste==NULL)
{
printf("ERREUR : Repertoire vide\n\nECHAP : revenir au Menu du repertoire");
fin=1;
}
else
{
while(fin==0) // si la liste n'est pas vide
{
printf("%s %s %s %s\n",(*ptr).UnContact.numerotel,(*ptr).UnContact.name,(*ptr).UnContact.pren,(*ptr).UnContact.adrmail); // on affiche le jeton
if((*ptr).p_suivant==0) // si le pointeur p_suivant de la fiche est null (en gros si on se trouve dans le dernier jeton de la liste
fin=1;
ptr=(*ptr).p_suivant; //on passe à la fiche suivante
}
free(ptr);
printf("\nECHAP : revenir au Menu du repertoire");
fin=0;
}
if (kbhit())
touche=getch();
}
}break;

case 2 :
{ // si on veut écrire dans le txt après avoir tout effacé
FILE* Repertoire = NULL;
Repertoire=fopen("Repertoire.txt","w+");
if(p_liste==NULL)
{
printf("ERREUR : Repertoire vide\n\nECHAP : revenir au Menu du repertoire");
fin=1;
}
while(fin==0) // si la liste n'est pas vide
{
if (Repertoire)
{
fprintf(Repertoire,"%s %s %s %s\n",(*ptr).UnContact.numerotel,(*ptr).UnContact.name,(*ptr).UnContact.pren,(*ptr).UnContact.adrmail); // on écrit
}
else
printf("ERREUR");
if((*ptr).p_suivant==0)
fin=1; //on passe à la fiche suivante
ptr=(*ptr).p_suivant; // le pointeur ptr pointe sur le p_suivant de sa fiche (au pire a la fin il pointera donc sur null)
}
fclose(Repertoire);
}break;
default:break; // le default c'est si y'a autre chose dans choix, içi c'est impossible, il ne sert a rien mais j'lai mis car l'an dernier le prof aimait bien qu'on le mette au cas ou.
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////



//####################################################################################################//
// //
//**********************************La fonction trier_1èrelettre**************************************//
// //
//####################################################################################################//

//recherche par première lettre
void trier_1erelettre(fiche *p_liste,char lettre,int choix_utilisation,char *nom_tape)
{
fiche *pointeur_de_tri;
pointeur_de_tri=p_liste; // 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 vace une valeur qui ne nous genera pas.
if(choix_utilisation==2)
system("cls"); // on efface la première phrase demandant quelle lettre l'utilisateur tape
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 et sinon on affiche le jeton
presence_contact=1;
}
if((strcmp(nom_tape,pointeur_de_tri->UnContact.name)==0) && choix_utilisation==5)
{
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 et sinon on affiche le jeton
presence_contact=1;
}
if((*pointeur_de_tri).p_suivant!=NULL) // si le pointeur suivant du jeton actuel est différent 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 ! et on ferme
fermeture=1; // on ferme la boucle quand on arrive a la fin de la liste chainée
}
if (presence_contact==0 && nbpassages==0 && choix_utilisation==2) // ce message doit s'afficher seulement au passage de la 1ère boucle sinon ça va écrire et réécrire et ect
printf("ERREUR : Aucuns contacts commençants par %c \n\nECHAP : revenir au Menu du repertoire",lettre);
if (presence_contact==1 && nbpassages==0 && choix_utilisation==2) // ce message doit s'afficher seulement au passage de la 1ère boucle sinon ça va écrire et réécrire et ect
printf("\nECHAP : revenir au Menu du repertoire\n");
}
else
{
if(nbpassages==0 && choix_utilisation==2)
printf("ERREUR, repertoire vide\n\nECHAP : revenir au Menu du repertoire");
}
nbpassages++;
if (kbhit())
touche=getch(); // pour sortir de la boucle avec la touche echap (code ascii 27)
if(choix_utilisation==5)
touche=27;
}
free(pointeur_de_tri);
}
///////////////////////////////////////////////////////////////////////////////////////////////////





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

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

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

//fonction tri alphabetique par tri par permutation
void trier_alphabetique (fiche** pp_liste)
{
FILE* repertoire=NULL;
int etatlecture=0,compteur=1,i=0,j=0,position=-1;
char nom[N+1],prenom[N+1],email[M+1],numtel[T+1];
*pp_liste=NULL;
repertoire=fopen("Repertoire.txt","r+");
if(repertoire) // on ouvre le repertoire
{
etatlecture=fscanf(repertoire,"%s%s%s%s",numtel,nom,prenom,email); // 1ère lecture
if (etatlecture!=EOF)
{
fiche* nouveau=(fiche*)malloc(sizeof(fiche)); // si y'a des écritures dans le fichier on crée 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; // et puis aintenant pp_liste est une liste "chainée" de ... 1 élément
}
etatlecture=fscanf(repertoire,"%s%s%s%s",numtel,nom,prenom,email); // 2 ième lecture
while (etatlecture!=EOF)
{
fiche* nouveau=(fiche*)malloc(sizeof(fiche)); // on créer la aussi un jeton
creation_jeton(nouveau,numtel,nom,prenom,email); // pareil, on entre les données
fiche* pcourant=*pp_liste; // on créer deux pointeurs tous deux initialiser 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) //et là on "regarde" où il faudra insérer le noveau jeton (par exemple sur le 3 ième parcoursu ect)
position=i;
p_parcours=p_parcours->p_suivant; // bien sur pour cela nous devons parcourir la liste chainée
}
if (position>=0) // si on a fait le if du desssus, on connais alors la position dans laquelle on doit réaliser l'insertion
{
for(j=0;j<position;j++)
pcourant=pcourant->p_suivant; // on recherche la bonne place pour insérer le jeton
nouveau->p_suivant=pcourant->p_suivant; // et quand on y est donc, on fait "passer" la liste chainée par nore jeton
pcourant->p_suivant=nouveau;
}
else // et ben sinon c'est déja trier
{
nouveau->p_suivant=*pp_liste;
*pp_liste=nouveau;
}
position=-1;
etatlecture=fscanf(repertoire,"%s%s%s%s",numtel,nom,prenom,email); // prochain passage dans le while
compteur++; // pour compter le nombre de contacts, on pourra faire un return compteur si besoin futur
}
fclose(repertoire);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////





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

/****************************************La fonction trier_date******************************************/

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

//fonction tri alphabetique par tri par permutation
void trier_date (jeton_SMS** pp_liste_chainee)
{
FILE* fichierSMS=NULL;
int etatlecture=0,compteur=1,i=0,j=0,position=-1;
char nom[N+1],prenom[N+1],email[M+1],numtel[T+1],buffer[150],horloge[128],SMS[tailleSMS],caractere;
*pp_liste_chainee=NULL;
fichierSMS=fopen("SMS.txt","r+");
if(fichierSMS) // on ouvre le repertoire
{
etatlecture=fscanf(fichierSMS,"%s%s%s%s%s%s",nom,prenom,numtel,email,buffer,horloge);printf("U\a"); // 1ère lecture
while(caractere!='\n')
{
caractere=fgetc(fichierSMS);
SMS[i]=caractere;
i++;
}
SMS[i]='\0';i=0;caractere='0';
if (etatlecture!=EOF)
{
jeton_SMS* nouveau=(jeton_SMS*)malloc(sizeof(jeton_SMS)); // si y'a des écritures dans le fichier on crée le jeton !!
creation_jetonSMS(nouveau,numtel,nom,prenom,email,buffer,horloge,SMS); // on le remplit
nouveau->p_suivant=*pp_liste_chainee; // on lui met l'adresse de pp_liste (NULL)
*pp_liste_chainee=nouveau; // et puis aintenant pp_liste est une liste "chainée" de ... 1 élément
}
etatlecture=fscanf(fichierSMS,"%s%s%s%s%s%s",nom,prenom,numtel,email,buffer,horloge);printf("1\a"); // 2 ième lecture
while(caractere!='\n')
{
caractere=fgetc(fichierSMS);
SMS[i]=caractere;
i++;printf("a%c",caractere);_sleep(50);
}
SMS[i]='\0';i=0;caractere='0';
while (etatlecture!=EOF)
{
jeton_SMS* nouveau=(jeton_SMS*)malloc(sizeof(jeton_SMS)); // on créer la aussi un jeton
creation_jetonSMS(nouveau,numtel,nom,prenom,email,buffer,horloge,SMS); // pareil, on entre les données
jeton_SMS* pcourant=*pp_liste_chainee; // on créer deux pointeurs tous deux initialiser sur la tete de pp_liste
jeton_SMS* p_parcours=*pp_liste_chainee;
for(i=0;i<compteur;i++)
{
if(strcmp(p_parcours->UnSMS.horloge,nouveau->UnSMS.horloge)<0 && strcmp(p_parcours->UnSMS.buffer,nouveau->UnSMS.buffer)<0) //et là on "regarde" où il faudra insérer le noveau jeton (par exemple sur le 3 ième parcoursu ect)
position=i;
p_parcours=p_parcours->p_suivant; // bien sur pour cela nous devons parcourir la liste chainée
}
if (position>=0) // si on a fait le if du desssus, on connais alors la position dans laquelle on doit réaliser l'insertion
{
for(j=0;j<position;j++)
pcourant=pcourant->p_suivant; // on recherche la bonne place pour insérer le jeton
nouveau->p_suivant=pcourant->p_suivant; // et quand on y est donc, on fait "passer" la liste chainée par nore jeton
pcourant->p_suivant=nouveau;
}
else // et ben sinon c'est déja trier
{
nouveau->p_suivant=*pp_liste_chainee;
*pp_liste_chainee=nouveau;
}
position=-1;
etatlecture=fscanf(fichierSMS,"%s%s%s%s%s%s",nom,prenom,numtel,email,buffer,horloge); // prochain passage dans le while
while(caractere!='\n')
{
caractere=fgetc(fichierSMS);
SMS[i]=caractere;
i++;
}
SMS[i]='\0';i=0;caractere='0';
compteur++; // pour compter le nombre de contacts, on pourra faire un return compteur si besoin futur
printf("%s %s %s %s %s %s %s",nom,prenom,numtel,email,buffer,horloge,SMS);_sleep(1000);
}
fclose(fichierSMS);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////



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

/************************************La fonction afficher_SMS****************************************/

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

/*ATTENTION : fontion affichage OU écriture du nouveau txt : 1 pour afficher 2 : pour écrire
SI elle reçoit 1 dans choix, il s'agit d'un simple affichage de la liste chainée, si c'est 2, elle copie tout les données du pointeur dans le répertoire après y avoir tout effacé au préalable*/
void afficher_SMS(jeton_SMS *p_liste_chainee,char choix)
{
int fin=0;
char touche='0',nomSMS[N];
jeton_SMS *ptr; // un pointeur de type jeton_SMS qui pointe sur la tete de la liste chainée
ptr=p_liste_chainee;printf("\a");
if (choix=='2')
{
printf("Entrez le nom du contact dont vous souhaitez afficher ses SMS\n");
scanf("%s",nomSMS);
}
while (touche!=27)
{
ptr=p_liste_chainee;
system("cls");
if(p_liste_chainee==NULL)
{
printf("ERREUR : Liste de SMS vide\n\nECHAP : revenir au Menu du repertoire");
fin=1;
}
else
{
while(fin==0) // si la liste n'est pas vide
{
printf("%s %s\n\n",(*ptr).UnSMS.buffer,(*ptr).UnSMS.horloge,(*ptr).UnSMS.SMS);
/*if(choix=='2' && strcmp(nomSMS,(*ptr).UnSMS.name)==0 || choix=='1')
printf("%s %s %s %s %s %s\n\n",(*ptr).UnSMS.numerotel,(*ptr).UnSMS.name,(*ptr).UnSMS.pren,(*ptr).UnSMS.adrmail,(*ptr).UnSMS.buffer,(*ptr).UnSMS.horloge,(*ptr).UnSMS.SMS); // on affiche le jeton*/
if((*ptr).p_suivant==0)
fin=1;
ptr=(*ptr).p_suivant;
}
free(ptr);
printf("\nECHAP : revenir au Menu du repertoire");
fin=0;
}
if (kbhit())
touche=getch();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////




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

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

//####################################################################################################
void supprimer_contact(fiche *p_liste,char *nom_suppr,char *prenom_suppr)
{
int fin=0,presence_contact=0;
char touchette='0';
fiche *p_courant=p_liste;
if (p_liste!=NULL) // si le répertoire s'ouvre on marque à la suite de tout ce qui y est marqué ce qui nous intéresse.
{
FILE* Repertoire = NULL;
Repertoire=fopen("Repertoire.txt","w+");
if (Repertoire)
{
while (fin==0)
{
if ((strcmp(nom_suppr,(*p_courant).UnContact.name)!=0) || (strcmp(prenom_suppr,(*p_courant).UnContact.pren)!=0)) // si le prenom ET le nom ne sont pas bons, il écrit les autres contacts
fprintf(Repertoire,"%s %s %s %s\n",(*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
else
presence_contact=1;
if ((*p_courant).p_suivant!=NULL)
p_courant=(*p_courant).p_suivant;
else
fin=1;
}
}
fclose(Repertoire);
}
system("cls");
while (touchette!=27)
{
if (presence_contact==1)
printf("Contact supprime\n\nECHAP : revenir au Menu du repertoire\n");
else
printf("ERREUR : Ce contact n'est pas present dans le repertoire\n\nEchap : Revenir au menu de Repertoire");
system("cls");
if(kbhit())
touchette=getch();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////




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

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

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

//c'est le case 4 du menu principal.
void modifier_contact(fiche **p_liste,char *nom_a_modifier,char *prenom_a_modifier)
{
fiche *pointeur_parcours=*p_liste; // le pointeur de type fiche qui va parcourir la liste doit etre initialiser par la tete
int fermeture=0,presence_contact=0,r,i;
char nom[N+1],prenom[N+1],adressmail[M+1],tel[T+1],touche='0'; // variables internes a la fonction
while (touche!=27)
{
while(fermeture!=1)
{
if(strcmp(nom_a_modifier,pointeur_parcours->UnContact.name)==0 && (strcmp(prenom_a_modifier,pointeur_parcours->UnContact.pren)==0)) // si le prenom OU le nom ne sont pas bons, il écrit les autres contacts) // si le nom est présent
{
system("cls");
strcpy(nom,verification_donne("nom",N)); // on fait appel à ces fonction pour s'assurer que l'utilisateur ne va pas entrer des betises
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 déja quelquepart dans la liste chainée (si déja : 1 sinon 0)
if (r==1)
{
system("cls");
printf("Ce numéro existe déja !!!\n\nECHAP : revenir au Menu du repertoire");
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 repertoire");
}
}
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 c'est qu'on est au bout, on ferme
}
if (presence_contact==0)
{
system("cls");
printf("Erreur ce contact n'existe pas\n\nECHAP : revenir au Menu du repertoire");
}
if (kbhit())
touche=getch();
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////




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

/************************************La fonction EcrireSMS*******************************************/

//####################################################################################################
void EcrireSMS(char *nomSMS, char *prenomSMS,char *telSMS,char *mailSMS,jeton_SMS** p_liste_chainee)
{
FILE* listeSMS = NULL;
char lettreSMS,SMS[tailleSMS+1],horloge[128];
int i=0,j=0,*pi=NULL;
pi=&i;
_tzset();
_strtime(horloge);
time_t time_of_day; //valeur contenant le temps écoulé depuis le 01/01/1970
char buffer[150]; //buffer contenant la chaîne finale
time_of_day = time( NULL ); //récupérer le temps passé
strftime(buffer,150,"%Y/%m/%d",localtime( &time_of_day ) ); //inscrire dans la chaîne buffer notre string telle que nous la voulons

listeSMS=fopen("SMS.txt","a+");
system("cls");
while (lettreSMS!=13&&i<tailleSMS)
{
system("cls");
printf("Entrez votre SMS (160 caracteres au maximum)\n");
printf("il vous reste %d/160\n",(160-*pi));
lettreSMS=getch();
SMS[i]=lettreSMS;
i++;
for (j=0;j<i;j++)
{
printf("%c",SMS[j]);
}
_sleep(100);
}
SMS[i-1]='\0';
if (listeSMS)
{
fprintf(listeSMS,"%s %s %s %s %s %s %s\n",nomSMS,prenomSMS,telSMS,mailSMS,buffer,horloge,SMS);
jeton_SMS* nouveau=(jeton_SMS*)malloc(sizeof(jeton_SMS)); // on crée un nouveau jeton de type jeton_SMS
(*nouveau).p_suivant=*p_liste_chainee; // le p_suivant de ce jeton prend l'adresse de p_liste_chainee
*p_liste_chainee=nouveau; // p_liste_chainee prend l'adresse de ce jeton
creation_jetonSMS(nouveau,telSMS,nomSMS,prenomSMS,mailSMS,buffer,horloge,SMS);
}
fclose(listeSMS);
}
///////////////////////////////////////////////////////////////////////////////////////////////////



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

/************************************La fonction envoyerSMS*******************************************/

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

void envoyerSMS(char choix,fiche *p_liste,jeton_SMS** p_liste_chainee)
{
char nomSMS[N+1],numSMS[T+1],touche='0';
int fermeture=0,presence_contact=0;
fiche *p_courant=p_liste;
system("cls");
while (touche!=27)
{
switch (choix)
{
case '1' :
{
printf("Saisissez le nom : ");
scanf("%s",nomSMS);
majuscules(nomSMS);

while (fermeture==0)
{
if(strcmp(nomSMS,p_courant->UnContact.name)==0) // si le nom est présent
{
EcrireSMS(nomSMS,p_courant->UnContact.pren,p_courant->UnContact.numerotel,p_courant->UnContact.adrmail,p_liste_chainee);
presence_contact=1;
}
if((*p_courant).p_suivant!=NULL) // si on est pas sur le dernier jeton on passe au suivant
p_courant=(*p_courant).p_suivant;
else
fermeture=1;
}
}break;
case '2' :
{
printf("Saisissez le numero : ");
scanf("%s",numSMS);
while (fermeture==0)
{
if(strcmp(numSMS,p_courant->UnContact.numerotel)==0) // si le nom est présent
{
EcrireSMS(p_courant->UnContact.name,p_courant->UnContact.pren,p_courant->UnContact.numerotel,p_courant->UnContact.adrmail,p_liste_chainee);
presence_contact=1;
}
if((*p_courant).p_suivant!=NULL) // si on est pas sur le dernier jeton on passe au suivant
p_courant=(*p_courant).p_suivant;
else
fermeture=1;
}
}break;
default :break;
}
choix='0';
if (kbhit())
touche=getch();
if (presence_contact==1)
{
system("cls");
printf("Votre SMS a bien ete envoye\n\nECHAP : revenir au Menu du repertoire");
}
else
{
system("cls");
printf("ERREUR : Contact non present dans le repertoire\n\nECHAP : revenir au Menu du repertoire");
}
}
}


///////////////////////////////////////////////////////////////////////////////////////////////////



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

/************************************La fonction EffacerSMS*******************************************/

//####################################################################################################
int EffacerSMS(char* nomSMS,char* prenom,char* numerotelephone,char* adresse_mail,jeton_SMS **p_liste_chainee)
{
int fin=0,retour=0;
system("cls");
jeton_SMS *ptr=*p_liste_chainee;
FILE* fichier_SMS = NULL;
fichier_SMS=fopen("SMS.txt","w+");
if(*p_liste_chainee==NULL)
{
printf("ERREUR : Liste de SMS vide\n\nECHAP : revenir au Menu du repertoire ");
fin=1;retour=-1;
}
while(fin==0) // si la liste n'est pas vide
{
if (fichier_SMS)
{
if(strcmp(ptr->UnSMS.name,nomSMS)!=0)
fprintf(fichier_SMS,"<%s %s %s %s> < %s %s> <%s>\n",ptr->UnSMS.name,ptr->UnSMS.pren,ptr->UnSMS.numerotel,ptr->UnSMS.adrmail,ptr->UnSMS.buffer,ptr->UnSMS.horloge,ptr->UnSMS.SMS);
retour=1;
}
else
printf("ERREUR");
if((*ptr).p_suivant==0)
fin=1; //on passe au jeton_SMS suivant
ptr=(*ptr).p_suivant; // le pointeur ptr pointe sur le p_suivant de sa fiche (au pire a la fin il pointera donc sur null)
}
fclose(fichier_SMS);
return retour;
}
//####################################################################################################

/************************************La fonction supprimerSMS****************************************/

//####################################################################################################
void supprimer_SMS(char choix,fiche* p_liste,jeton_SMS**p_liste_chainee)
{
char touche='0',nomSMS[N+1],numSMS[T+1];
int fermeture=0,presence_contact=0;
fiche *p_courant=p_liste;
system("cls");
while (touche!=27)
{
switch (choix)
{
case '1' :
{
printf("Saisissez le nom : ");
scanf("%s",nomSMS);
while (fermeture==0)
{
if(strcmp(nomSMS,p_courant->UnContact.name)==0) // si le nom est présent
{
presence_contact=EffacerSMS(nomSMS,p_courant->UnContact.pren,p_courant->UnContact.numerotel,p_courant->UnContact.adrmail,p_liste_chainee);
fermeture=1;
}
if((*p_courant).p_suivant!=NULL) // si on est pas sur le dernier jeton on passe au suivant
p_courant=(*p_courant).p_suivant;
else
fermeture=1;
}
}break;
case '2' :
{
printf("Saisissez le numero : ");
scanf("%s",numSMS);
while (fermeture==0)
{
if(strcmp(numSMS,p_courant->UnContact.numerotel)==0) // si le nom est présent
{
presence_contact=EffacerSMS(p_courant->UnContact.name,p_courant->UnContact.pren,p_courant->UnContact.numerotel,p_courant->UnContact.adrmail,p_liste_chainee);
fermeture=1;
}
if((*p_courant).p_suivant!=NULL) // si on est pas sur le dernier jeton on passe au suivant
p_courant=(*p_courant).p_suivant;
else
fermeture=1;
}
}break;
default :break;
}
choix='0';
if (kbhit())
touche=getch();
if (presence_contact==1)
{
system("cls");
printf("Votre SMS a bien ete supprime\n\nECHAP : revenir au Menu du repertoire");
}
if (presence_contact==0)
{
system("cls");
printf("ERREUR : Contact non present dans le repertoire\n\nECHAP : revenir au Menu du repertoire");
}
}
}


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

/******************************LA fonction demande_suppr_ou_modif************************************/

//####################################################################################################
char *demande_suppr_ou_modif(fiche *p_liste,char *pointeur_nom,char *pointeur_prenom,char *role)
{
pointeur_nom=0;*pointeur_prenom=0;
char nom_a_modifier[N+1],prenom_a_modifier[N+1];
system("cls");
printf("Entrer le nom du contact a %s : ",role);
scanf("%s",nom_a_modifier);
strcpy(nom_a_modifier,majuscules(nom_a_modifier)); // pour mettre en majuscule le nom en entier
trier_alphabetique(&p_liste);
trier_1erelettre(p_liste,nom_a_modifier[0],5,nom_a_modifier);
printf("\nEntrer le prenom du contact a %s : ",role);
scanf("%s",prenom_a_modifier);
strcpy(prenom_a_modifier,majuscules(prenom_a_modifier)); // pour mettre en majuscule le prenom en entier
trier_alphabetique(&p_liste);
pointeur_nom=nom_a_modifier;
pointeur_prenom=prenom_a_modifier;printf("A");printf("%s",(pointeur_nom));
}
///////////////////////////////////////////////////////////////////////////////////////////////////



/*######################################################################################################

/****************************************LE MENU PRINCIPAL******************************************/

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

int main ()
{
int nbcontacts=0,i;
char touche='0',lettre,nom_a_modifier[N+1],nom_a_supprimer[N+1],prenom_a_supprimer[N+1],prenom_a_modifier[N+1],choix;
fiche *p_liste=NULL;char *pointeur_nom="toto",*pointeur_prenom="tata";
jeton_SMS *p_liste_chainee=NULL;
while (touche!=27)
{
system("cls");
if (kbhit()) // si l'utilisateur tape des touches on met ça dans touche
touche=getch();

printf("--------------- MENU DU TELEPHONE ---------------\n\n1:\tListe complete des contacts\n2:\tListe des contacts commencant par...\n3:\tAjouter un contact\n4:\tModifier un contact\n5:\tSupprimer un contact\n6:\tEnvoyer un SMS\n7:\tSupprimer un SMS\n8:\tListe des SMS envoyes\n\nECHAP: Sortir du programme\n");

switch(touche)
{
case '1' :
{
system("cls");
trier_alphabetique(&p_liste);
afficher(p_liste,1);
touche='0';
}break;

case '2' :
{
system("cls");
printf("Entrer la première lettre : ");
scanf("%c",&lettre);
lettre=toupper(lettre);
trier_alphabetique(&p_liste);
trier_1erelettre(p_liste,lettre,2,"nonutile");
touche='0';
}break;

case '3' :{
trier_alphabetique(&p_liste);
ajouter(&p_liste);
touche='0';
}break;

case '4' :{
demande_suppr_ou_modif(p_liste,nom_a_modifier,prenom_a_modifier,"modifier");/*
system("cls");
printf("Entrer le nom du contact a modifier : ");
scanf("%s",nom_a_modifier);
strcpy(nom_a_modifier,majuscules(nom_a_modifier)); // pour mettre en majuscule le nom en entier
trier_alphabetique(&p_liste);
trier_1erelettre(p_liste,nom_a_modifier[0],5,nom_a_modifier);
printf("\nEntrer le prenom du contact a modifier : ");
scanf("%s",prenom_a_modifier);
strcpy(prenom_a_modifier,majuscules(prenom_a_modifier)); // pour mettre en majuscule le prenom en entier
trier_alphabetique(&p_liste);*/
modifier_contact(&p_liste,nom_a_modifier,prenom_a_modifier);
touche='0';
afficher(p_liste,2);
}break;

case '5' :{
//demande_suppr_ou_modif(p_liste,&nom_a_modifier,&prenom_a_modifier,"supprimer");
system("cls");
printf("Entrer le nom du contact a supprimer : ");
scanf("%s",nom_a_supprimer);
strcpy(nom_a_supprimer,majuscules(nom_a_supprimer)); // pour mettre en majuscule le nom en entier
trier_alphabetique(&p_liste);
trier_1erelettre(p_liste,nom_a_supprimer[0],5,nom_a_supprimer);
printf("\nEntrer le prenom du contact a supprimer : ");
scanf("%s",prenom_a_supprimer);
strcpy(prenom_a_supprimer,majuscules(prenom_a_supprimer)); // pour mettre en majuscule le prenom en entier
trier_alphabetique(&p_liste);
supprimer_contact(p_liste,nom_a_supprimer,prenom_a_supprimer);
trier_alphabetique(&p_liste);
touche='0';
afficher(p_liste,2);
}break;

case '6' :{
system("cls");
printf("Vous desirez envoyer a:\n1: un nom\n2: un numero de telephone\n");
choix=getch();
trier_alphabetique(&p_liste);
envoyerSMS(choix,p_liste,&p_liste_chainee);
touche='0';
}break;

case '7' :{
system("cls");
printf("Vous desirez supprimer :\n1: un nom\n2: un numero de telephone\n");
choix=getch();
trier_alphabetique(&p_liste);
supprimer_SMS(choix,p_liste,&p_liste_chainee);
touche='0';
}break;

case '8' :{
system("cls");
printf("Vous désirez afficher la liste des SMS :\n1: de tous les contacts triée par date\n2: d'un contact trié par date\n");
choix=getch();
trier_date(&p_liste_chainee);
afficher_SMS(p_liste_chainee,choix);
touche='0';
}break;

default : break;
}
fflush(stdin); // pour vider le clavier
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/* ATTENTION
la lecture du sms et la mise dans le jeton ne fonctionne pas très bien avec un fscanf !!!!
*/

merci lami20j pour tes réponses.

Quand au 1) , pas besoin de mettre le "struct" car j'avais mis un fiche juste avant d'ouvrir l'accolade.
Pour le 2), c'est astucieux, ça fait gagner une ligne au programme (qu idevient très long).

Je voulais te demander comment retourner 2 chianes de caractères d'une fonction, c'est mon principal soucis.
D'ailleurs j'ai mis ça dans mon main, dans la case 4 :

/*demande_suppr_ou_modif(p_liste,&nom_a_modifier,&prenom_a_modifier,"modifier");*/

cette fonction demande_suppr_ou_modif doit retourner au main 2 chaines. J'ai mis en arguments l'adresse des chaines, donc dans les arguments de la fonction des pointeurs de chaines de caractères.
Malheureusement il y a un pb de compilation, qui me dit :
"cannot convert char(*)(31) to char ** for argument 2 to char *demande_suppr_ou_modif

voilà merci pour l'aide, je reste connecté et je repasse régulièrement.

++

ah merci bien lami20j.
en faite je ne savait pas bien si une chaine de caractère était bien un pointeur de caractères.

merci beaucoup et bon week end !!