Bonjour,

 
Je ne sais pas comment appeller la fonction mdelete pour que celle-ci supprime un element deja entre par l'utilisateur.
 
Quand le choix 2 est executee, mdelete() doit etre appelle pour qu'elle supprime un mot. Mais j'ai un probleme en appellant cette fonction.
 
Si quelqu'un me guider sur comment organiser les choses dans if ( choice == 2 ) {}
 
Merci.

Il manquerait pas un argument dans ton appel à mdelete ?

Oui mais c'est pas comme ca que je devrais l'appeller.
 
Comment je devrais appeller mdelete, et quelles sont les arguments a mettre ? Car j'ai des erreurs quand je compile.
 
Merci de votre aide

Je sais qu'il faudrait y mettre 4 arguments, mais que seront ces arguments? car je suis un peu perdu avec tout ses pointers.

Ben, il manque un paramètre, et je suis pas sûr de ta procédure mdelete, mais, mdelete(p, start, last) devrais faire l'affaire et le i ne serait pas un parametre de la procédure mdelete mais une variable. Mais je suis pas sûr, il faut que je relise, désolé.  

If (p) .... //

 
Cette instruction veut dire "si le pointeur p n'est pal nul", nest- ce pas ?

Oui c'est ca...

fait la recherche du mot dans la liste je présume et que donnes les paramètres effectifs de la procédure mdelete.
 
Une recherche dans une liste chaîné non ordonnée, je crois vaguement, plus ou moins formellement donc, que c'est un parcours des élément O=n si je ne m'abuse.

perso, j'aime bien réserver les boucle for pour les conditions les mieux adaptées, mais j'ai l'abitude d'écrire en Ada, mais un for ou un while avec l'index i qui parcoure la liste est du tdonne p, start, last et i, dans les bonne case.

Au fur et a mesure que tu compares i->word avec P->word tu fais i = i->next,

j'ai pas trop compris ta reponse... donc c'est quoi la solution?

une boucle while ou for, à toi de choisir.

for (i->word, p->word != NULL, i = i->next) {}
mdelete (p,start,last,i);
 
 
cela ferais-t-il l'affaire ?
 
 

for (i-= start , p != NULL, i = i->next)  
{
if (i->word == p->word) break;
}
mdelete (p,i,start,last);
 
 
si break te permet de sortir de la boucle.
 
il faut que tu declare i dans la partie declarative du la fonction main

tu fais quoi au juste en français dans ta procedure mdelete ?

 
Comme ca ?

Le compileur m'affice quelques erreurs
 

il faut que tu déclares i comme tu as déclaré start et p, déclares last aussi.
 
Mais après j'ai un problème avec la fonction mdelete, je comprend pas ce que tu veux faire.
 
 
 
En français alors ?
 
 
Et il faut que tu fasse suivre last dans "choice 1".

un '*' c'est un pointeur, une adresse, bref, un "**" c'est quoi, un pointeur sur un pointeur ?
 

J'appelle desormais mdelete comme ceci

 
Le code compile mais il y a une seg fault quand j'entre le mot a supprimer... est ce que c'est un probleme dans scanf() ?  
 
 

 
Peux-tu etre plus precis ?

A, ben non, c'est p last, donc tu affecte p à last avant de saisir ton mot à supprimer.
 
Mais j'avais pas vu, c'est pas dans l'ordre dans "choice 1"

J'essai d'écrire le code, mais il est tard déjà, A+

int main ( void )
{ int choice;
  struct list *start, *p, *i, *last ;
  start = malloc ( sizeof (struct list));
  start->next = NULL;
do {
    printf("\n\n\t 1.  Add a word" );
    printf("\n\t 2.  Delete a word" );
    printf("\n\t 3.  Search for and display" );
    printf("\n\t 4.  Display data in queue order" );
    printf("\n\t 5.  Quit" );
    printf("\n\n\t Enter your choice : " );
    scanf("%i", & choice);
    if ( choice == 1 ) {
      printf("\n\tEnter the word to add : " );
      scanf("%s", p->word);
      for(p = start; p->next != NULL; p = p->next)
    {
      p->next = malloc (sizeof(struct list));
      p->next->next = NULL;
    }
      last = p->next;
        
     }
    if ( choice == 2 ) {
        printf("\n\tEnter the word to delete : " );
        scanf("%s", p->word);
        mdelete(p, i, &start, &last);   
        Printlist ( start );
        }
    if ( choice == 4 ) {
        Printlist ( start );
        }
    } while ( choice != 5 );
return 0;

 
Mais il génère une erreur à l'execution.

# include <stdio.h>
# include <string.h>
# include <stdlib.h>
struct list  {
  char word [ 50 ];
  struct list * next;
  };
void Printlist (struct list * );
void mdelete( struct list *p,
              struct list *i,
              struct list **start,
              struct list **last)
{
    if(p) p->next = i->next;
    else *start = i->next;
    if(i==*last && p) *last = p;
}
int main ( void )
{ int choice;
  struct list *start, *p, *i, *last ;
  start = malloc ( sizeof (struct list));
  start->next = NULL;
do {
    printf("\n\n\t 1.  Add a word" );
    printf("\n\t 2.  Delete a word" );
    printf("\n\t 3.  Search for and display" );
    printf("\n\t 4.  Display data in queue order" );
    printf("\n\t 5.  Quit" );
    printf("\n\n\t Enter your choice : " );
    scanf("%i", & choice);
    if ( choice == 1 ) {
      printf("\n\tEnter the word to add : " );
      scanf("%s", p->word);
      for(p = start; p->next != NULL; p = p->next)
    {
      
    }
      p->next = malloc (sizeof(struct list));
      p->next->next = NULL;
      last = p->next;
        
    }
    if ( choice == 2 ) {
      
      
      printf("\n\tEnter the word to delete : " );
      scanf("%s", p->word);
    for (i = start ; p != NULL; i = i->next)  
      {
        if (i->word == p->word) break;
      }
        mdelete(p, i, &start, &last);   
        Printlist ( start );
    }
    if ( choice == 4 ) {
      Printlist ( start );
    }
} while ( choice != 5 );
 return 0;
}
void Printlist (struct list * x)
{
  int v = 1;
  while ( x != NULL ) {
        printf ("\n\tElement %i is : %s \n", v++, x->word);
        x = x->next;
        }
}

 
 
Pour copier coller, double clique dans l'encadrement du code, ça efface les numéro de ligne.
 
 
Mais ça marche pas encore.

 
   
Bon désolé pour l'aide je vais dodoter, je repasserai demain (enfin tout à l'heure).
Pour commencer utilise fgets au lieu de scanf, ce sera déjà ça de gagné...

 
C'est toi qui a écrit la fonction mdelete ? Dans ce cas tu devais avoir une logique en l'écrivant. Donc tu devrais savoir l'utiliser !!!!
Déjà son premier paramètre c'est un pointeur sur un "struct list" donc tu peux absolument pas lui passer p->word qui est un pointeur sur un char...
 
Moi, je te conseillerais de bien concevoir tes objets car c'est peut-être du temps passé au départ mais ça simplifie grandement la vie ensuite. Déjà, conceptuellement parlant, le truc qui stocke un mot et un pointeur sur le truc suivant c'est pas une "liste" mais un "élément de ta liste". Donc si tu l'appelais "struct elem" peut-être que tu verrais mieux ce que tu manipules.
Ensuite, ben tu pourrais très bien concevoir un truc pour manipuler ta liste. Ce truc qui pourrait être un "struct list" contiendrait par exemple un pointeur sur le premier élément (voire un pointeur sur le dernier si tu en as envie ou encore le nombre d'éléments ou autre). Ensuite il te suffirait de passer à chaque fonction l'adresse de ce "struct list" donc tes fonctions recevraient un "struct list *" et 1) rien qu'avec ce pointeur tu aurais accès au premier élément de ta liste et aussi au dernier (tu évites donc le "start" et le "last" ) et 2) tu n'irais pas te débattre avec des "**" à profusion dans lesquels tu n'arrives pas à t'y retrouver et tu rends ton code illisible.
 
Autre détail => Dans ton main, tu commences par initialiser "start" puis tu travailles ensuite sur p->next (donc tu travailles sur 2 éléments à la fois). Tu te compliques trop la vie et tu ouvres la porte aux bugs. Apprends à découper tes tâches de base en fonctions puis appelle les fonctions qu'il faut quand il faut
 
Dernier détail => les commentaires ne sont pas une légende urbaine => ils existent (et en mettre te permettra de garder en tête ton idée directrice)
 
Tiens, juste pour l'exemple, voici les structures telles que je les vois et la réécriture de ta fonction mdelete telle que je l'ai comprise

struct elem {
    char word[50];
    struct elem *next;
};
 
struct list {
    struct elem *first;
    struct elem *last;
};
 
void init(struct list *liste)
{
     liste->first=NULL;
     liste->last=NULL;
}
 
// Fonction qui efface un élément de la liste
void delete(struct list *liste, struct elem *elem)
{
    struct elem *cur;
    struct elem *prev;
 
    // Si la liste est vide il n'y a rien à effacer
    if (liste->first == NULL) return;
 
    // Positionnement des deux éléments "prev" et "cur" sur l'élément juste avant et sur l'élément à effacer
    for (cur=liste->first, prev=NULL; cur != elem; prev=cur, cur=cur->next);
 
    // Si l'élément précédent existe
    if (prev)
        // L'élément précédent prend l'adresse du suivant
        prev->next=cur->next;
    else
        // L'élément à supprimer était le premier => celui-ci change
        liste->first=cur->next;
 
    // Si l'élément à effacer était le dernier
    if (cur->next == NULL)
        // Le dernier élément de la liste change
        liste->last=cur;
 
    // L'élément à effacer est supprimé
   free(elem);
}
 
// Fonction qui efface un mot de la liste
void mdelete(char *word, struct list *liste)
{
    struct elem *cur;
 
    // Recherche du mot dans la liste
    for (cur=liste->first; cur != NULL; cur=cur->next)
    {
          if (strcmp(cur->word, word) == 0)
             break;
    }
 
    // Si l'élément contenant le mot a été trouvé
    if (cur)
        // Il est supprimé de la liste
       delete(liste, cur);
}

   
 
Le reste à l'avenant (fonction pour créer et remplir un élément, pour insérer un élément, pour afficher un élément, pour afficher toute la liste etc...)
 
Ensuite, l'écriture du programme est hyper simple

int main()
{
    struct list liste;
 
    // Initialisation de la liste
    init(&liste);
 
    // Menu
    ...
 
    // Evaluation du menu
    switch(...)
    {
         case 1:
               ...
               break;
         case 2: // Suppression d'un mot
            <... stockage du mot à supprimer ...>
            mdelete(mot, &liste);
            break;
         ...
     }
}

 
 
 
Pas étonnant => le code est aussi pourri que celui de vituoz. Arrêtez de vouloir tout faire dans le main et de taper du code à l'arrache sans comprendre où vous allez !!!

Merci pour ta reponse. Mais il y a bcp de bugs...
 
Il y a un probleme avec la fonction init de la ligne 11. Qu'est ce que "s_list"? serait-elle "list" tout court ?
 

 
 
Dans la fonction delete.  

 
Est ce que dans les lignes 35 et 40, tu as voulu ecrire "liste" au lieu de "list" ?
 
 
Autre question, pourquoi n'as tu pas utilise d'allocation dynamique ?
 
Qu'en est-il du stockage de mot dans la fonction main ?
 
 
 
 
 

Quel variable doit-il y a voir pour le stockage de mot ? est ce que ca doit etre un pointeur ? ou bien la variable "word" ?

Oui, j'ai l'habitude de nommer mes structures "s_" et donc quand j'ai tapé mon code cette habitude est ressortie. J'ai rectifié mon post pour corriger les noms
 

Ah ça c'est la fonction "remplirElem()" qui le fera. Tu lui passes en paramètre le mot à stocker et elle alloue la mémoire, stocke le mot et met le pointeur next à NULL et te renvoie un pointeur sur l'élément alloué. Puis une fois ce pointeur en main, tu le passes à la fonction "insereElem()" qui met cet élément à la bonne place dans la liste. Les deux opérations pourraient tout à fait se faire ensemble mais en les séparant, tu peux mieux gérer la modularité de ton programme. Tu peux par exemple avoir une fonction qui insère toujours au début, une autre qui insère toujours à la fin, une 3° qui insère dans l'ordre alphabétique et tu appelles celle que tu veux quand tu veux. Mais bien entendu faut que tu les écrives (je vais pas tout te faire non plus)...
 

Le mot qu'on veut enlever ? A toi de déclarer la variable adéquate et la faire remplir par la fonction que tu voudras. Je t'ai tapé un "squelette" de programme pour que tu comprennes l'idée générale de ce genre de truc mais faut quand-même que tu fasses des trucs par toi-même...
 

C'est pas mauvais. Faut juste que tu définisses ta variable "word" comme une variable qui te permet de saisir un mot (donc des lettres) => par exemple char word[50]...

Reste une erreure quand je compile:
 

 
Qu'est ce qui cloche avec la fonction init ?

C'est la structure d'avant qui n'est pas terminee avec un point virgule ;