un petit probleme dans mon code

**hanene_z** · 19/12/2006, 20h50

bonjour

je doit realiser un tp de liste chainee(chaque noeud de la liste contien un champs de nom d'evenement et un autre pour le temps d'evenement)
l'insertion dans cette liste doit se faire a l'aide d'une procedure insertion qui a deux pametres le nom de l'evenement et le temps a la fin la liste doit etre triee selon l'ordre croissant de temps d'evenement
le pbm est lors l'execution du tp surtout si j'entre beaucoup de donnee il ya des informations qui seront perdu
a votre avis quel est le pbm
voici mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
#include<string.h>
#include <ctype.h>
 
typedef struct gestevent
{
   char name[10];
   float tevent;
   gestevent*suivant;
};
gestevent *courant,*debut;
 
/*-------------definition des fonctions-----------*/
int menuprincipal()
{
   int menu;
 
   clrscr();
   printf("1.insertion\n2.consultation\n3.suppression\n4.quitter l'appliction");
   printf("\nchoix menu:");
   scanf("%d",&menu);
   return menu;
}
 
void insert(char event[10],float tps)
{
   gestevent*prec,*nouveau;
   char choix;
   int i;
 
   /*creation de la liste*/
   debut=(gestevent*)malloc(sizeof(gestevent));
   courant=debut;
   clrscr();
   printf("\n\nEtrez nom de l'evenement:");
   scanf("%s",event);
   strcpy(courant->name,event);
   printf("\nentez le temps de l'evenement:");
   scanf("%f",&tps);
   courant->tevent=tps;
   courant->suivant=NULL;
   do
   {
      printf("\n Autre saisie? o/n");
      choix=getche();
      if(choix=='o'||choix=='O')
      {
         goto nouv;
      }
      else
      {
         goto fin;
      }
nouv:
      nouveau=(gestevent*)malloc(sizeof(gestevent));
      printf("\n\nEtrez nom de l'evenement:");
      scanf("%s",event);
      strcpy(nouveau->name,event);
      printf("\nentez le temps de l'evenement:");
      scanf("%f",&tps);
      nouveau->tevent=tps;
      if (nouveau->tevent<=debut->tevent)
      {
         nouveau->suivant=debut;
         debut=nouveau;
      }
      else
      {
         courant=debut;
         while(courant->suivant!=NULL)
         {
            courant=courant->suivant;
         }
         if(nouveau->tevent>=courant->tevent)
         {
            nouveau->suivant=NULL;
            courant->suivant=nouveau;
         }
         else
         {
            courant=debut;
            prec=courant;
            while(courant!=NULL)
            {
               if (nouveau->tevent<=courant->tevent)
               {
                  prec->suivant=nouveau;
                  nouveau->suivant=courant;
               }
               prec=courant;
               courant=courant->suivant;
            }
         }
      }
   }while(choix=='o'||choix=='O');
fin:
}
 
/*-------------------fonction d'affichage-----------------------*/
void affichage()
{
   clrscr();
   courant=debut;
   if(debut==NULL)
   {
      printf("la liste est vide");
   }
 
   while(courant!=NULL)
   {
      printf("\n name:%s",courant->name);
      printf("\ntevent:%.2f",courant->tevent);
      courant=courant->suivant;
   }
   getch();
}
 
void extract()
{
   clrscr();
   if(debut==NULL)
   {
      printf("la liste est vide");
   }
   else
   {
      printf("\nl'‚lement supprim‚ est :%s %.2f",debut->name,debut->tevent);
      free(debut);
      debut=debut->suivant;
   }
   getch();
}
 
char e[10];
float t;
int menu;
 
void main()
{
   clrscr();
   do
   {
      menu=menuprincipal();
      switch(menu)
      {
         /*--------------------------------------------*/
         case 1:/*appel … la fonction insertion*/
            insert(e,t);
            break;
 
         /*--------------------------------------------*/
         case 2:/*consultation de la liste chainee*/
            affichage();
            break;
 
         /*------------------------------------------*/
         case 3:/*suppression du premier element*/
            extract();
            break;
      }/*fin de switch case*/
 
   /*----------------------------------------*/
   }while (menu!=4);
}

MERCI

**Emmanuel Delahaye** · 19/12/2006, 21h27

Envoyé par hanene_z

voici mon code:

#include <stdio.h>

Merci de lire les regles du forum et d'apprendre à utiliser les balises code... (

)

Ensuite, il est préférable de corriger les fautes avant de poster...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : C:\dev\forums2\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:3:19: alloc.h: No such file or directory
main.c:11: error: syntax error before "gestevent"
main.c:11: warning: no semicolon at end of struct or union
main.c:13: error: syntax error before '*' token
main.c:13: warning: type defaults to `int' in declaration of `courant'
main.c:13: warning: type defaults to `int' in declaration of `debut'
main.c:13: warning: data definition has no type or storage class
main.c:16: warning: function declaration isn't a prototype
main.c: In function `menuprincipal':
main.c:18: warning: implicit declaration of function `clrscr'
main.c: In function `insert':
main.c:26: error: `gestevent' undeclared (first use in this function)
main.c:26: error: (Each undeclared identifier is reported only once
main.c:26: error: for each function it appears in.)
main.c:26: error: `prec' undeclared (first use in this function)
main.c:26: error: `nouveau' undeclared (first use in this function)
main.c:26: warning: left-hand operand of comma expression has no effect
main.c:30: error: syntax error before ')' token
main.c:35: error: request for member `name' in something not a structure or union
main.c:38: error: request for member `tevent' in something not a structure or union
main.c:39: error: request for member `suivant' in something not a structure or union
main.c:51: error: syntax error before ')' token
main.c:58: error: request for member `tevent' in something not a structure or union
main.c:66: error: request for member `suivant' in something not a structure or union
main.c:68: error: request for member `suivant' in something not a structure or union
main.c:70: error: request for member `tevent' in something not a structure or union
main.c:73: error: request for member `suivant' in something not a structure or union
main.c:80: error: request for member `tevent' in something not a structure or union
main.c:86: error: request for member `suivant' in something not a structure or union
main.c:92: error: label at end of compound statement
main.c:28: warning: unused variable `i'
main.c: At top level:
main.c:95: warning: function declaration isn't a prototype
main.c: In function `affichage':
main.c:104: error: request for member `name' in something not a structure or union
main.c:105: error: request for member `tevent' in something not a structure or union
main.c:106: error: request for member `suivant' in something not a structure or union
main.c: At top level:
main.c:111: warning: function declaration isn't a prototype
main.c: In function `extract':
main.c:119: error: request for member `name' in something not a structure or union
main.c:119: error: request for member `tevent' in something not a structure or union
main.c:120: warning: implicit declaration of function `free'
main.c:121: error: request for member `suivant' in something not a structure or union
main.c: At top level:
main.c:129: warning: function declaration isn't a prototype
main.c:129: warning: return type of 'main' is not `int'
main.c: In function `insert':
main.c:26: warning: statement with no effect
Process terminated with status 1 (0 minutes, 3 seconds)
27 errors, 14 warnings

Voici ton code rendu compilable et présentable...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#include <stdio.h>
#include<string.h>
#include <ctype.h>
#include <stdlib.h>
 
typedef struct gestevent
{
   char name[10];
   float tevent;
   struct gestevent *suivant;
}
gestevent;
 
gestevent *courant, *debut;
/*-------------definition des fonctions-----------*/
int menuprincipal (void)
{
   int menu;
   printf
      ("1.insertion\n"
       "2.consultation\n"
       "3.suppression\n"
       "4.quitter l'application");
   printf ("\nchoix menu:");
   scanf ("%d", &menu);
   return menu;
}
 
void insert (char event[10], float tps)
{
   gestevent *prec, *nouveau;
   char choix;
/*creation de la liste*/
   debut = (gestevent *) malloc (sizeof (gestevent));
   courant = debut;
   printf ("\n\nEtrez nom de l'evenement:");
   scanf ("%s", event);
   strcpy (courant->name, event);
   printf ("\nentez le temps de l'evenement:");
   scanf ("%f", &tps);
   courant->tevent = tps;
   courant->suivant = NULL;
   do
   {
      printf ("\n Autre saisie? o/n");
      choix = getchar ();
      if (choix == 'o' || choix == 'O')
      {
         goto nouv;
      }
      else
      {
         goto fin;
      }
    nouv:
      nouveau = (gestevent *) malloc (sizeof (gestevent));
      printf ("\n\nEtrez nom de l'evenement:");
      scanf ("%s", event);
      strcpy (nouveau->name, event);
      printf ("\nentez le temps de l'evenement:");
      scanf ("%f", &tps);
      nouveau->tevent = tps;
      if (nouveau->tevent <= debut->tevent)
      {
         nouveau->suivant = debut;
         debut = nouveau;
      }
      else
      {
         courant = debut;
         while (courant->suivant != NULL)
         {
            courant = courant->suivant;
         }
         if (nouveau->tevent >= courant->tevent)
         {
            nouveau->suivant = NULL;
            courant->suivant = nouveau;
         }
         else
         {
            courant = debut;
            prec = courant;
            while (courant != NULL)
            {
               if (nouveau->tevent <= courant->tevent)
               {
                  prec->suivant = nouveau;
                  nouveau->suivant = courant;
               }
               prec = courant;
               courant = courant->suivant;
            }
         }
      }
   }
   while (choix == 'o' || choix == 'O');
 fin:
   ;
}
 
/*-------------------fonction d'affichage-----------------------*/
void affichage (void)
{
   courant = debut;
   if (debut == NULL)
   {
      printf ("la liste est vide");
   }
   while (courant != NULL)
   {
      printf ("\n name:%s", courant->name);
      printf ("\ntevent:%.2f", courant->tevent);
      courant = courant->suivant;
   }
}
 
void extract (void)
{
   if (debut == NULL)
   {
      printf ("la liste est vide");
   }
   else
   {
      printf ("\nl'‚lement supprim‚ est :%s %.2f", debut->name,
              debut->tevent);
      free (debut);
      debut = debut->suivant;
   }
}
 
int main (void)
{
   int menu;
 
   do
   {
      char e[10];
      float t;
 
      menu = menuprincipal ();
      switch (menu)
      {
      case 1:                  /*appel … la fonction insertion */
         insert (e, t);
         break;
      case 2:                  /*consultation de la liste chainee */
         affichage ();
         break;
      case 3:                  /*suppression du premier element */
         extract ();
         break;
      }                         /*fin de switch case */
   }
   while (menu != 4);
   return 0;
}

Il n'en demeure pas moins d'une qualité de réalisation médiocre (globales, goto...)

Un bon 8 ou 9... http://emmanuel-delahaye.developpez.com/goret.htm

et que dans main(), t n'est pas initialisé (ça mérite un 10 !)

En P.J., une version sans globales. Ca corrige déjà certaines absurdités... (une libération 'folklorique', par exemple...)

**XxghostxX** · 20/12/2006, 12h40

depuis la debut de mon apprentissage les enseignant nous interdise l'utilisation de goto je conçoi que sa ne rend pas le code trés cler mais y a t'il une autre raison? portabilité , relecture par d'autre ...
si tu pouvez me repondre emmanuel merci

**salseropom** · 20/12/2006, 15h13

Avec les goto, les codes sont illisibles. Le lecteur passera son temps à aller d'un endroit à un autre. A la place d'un goto, il vaut mieux faire une fonction. C'est plus lisible.

**Emmanuel Delahaye** · 20/12/2006, 15h31

Envoyé par XxghostxX

depuis la debut de mon apprentissage les enseignant nous interdise l'utilisation de goto je conçoi que sa ne rend pas le code trés cler mais y a t'il une autre raison? portabilité , relecture par d'autre ...
si tu pouvez me repondre emmanuel merci

La portabilité n'est pas en cause. C'est plus un question de cohérence dans l'écriture du code. En effet, le C est un langage qui est basé sur les principes de la programmation structurée comme le Pascal et la plupart des langages modernes.

Historiquement c'est évidemment l'assembleur (langage de 1ère génération) qui a imposé son style codage et de reflexion. Celui-ci est basé sur le saut, conditionnel ou non. C'est dû au fonctionnement interne d'un processeur, qui veut qu'un programme s'exécute en séquence selon le compteur d'instructions. Si il faut exécuter du code 'ailleurs', il faut brutalement modifier le compteur d'instruction pour signifier le 'ailleurs' au processeur.

On utilise pour ça une instruction de saut (JMP, LJMP), ou de saut conditionnel (JNE JZ JGT etc.) ou de saut avec retour (CALL, JSR). Un saut peut se faire indifféremment vers l'avant ou vers l'arrière.

Ce mode de pensée 'par saut' a été modélisé sous la forme d'ordinogrammes présentants des exécutions linéaires,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
    |
 -------
|       |
 -------
    |

des décisions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
     |
    / \ NO
     ? --- 
    \ /
     |YES

et des sauts.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Cette culture du saut a généré du code extrêmement difficile à lire et à maintenir, surtout si on ne disposait plus du document de conception (l'ordinogramme).

Le BASIC originel avec numéros de lignes (langage de 2ème génération), était basé sur la même culture du saut, entrainant les mêmes difficultés.

Il m'est arrivé personnellement de récupérer du code assembleur écrit par des personnes issue de cette 'culture du saut' et de passer 1 à 2 jours à essayer de dessiner l'ordinogramme, ce qui est extrêmement difficile, si on a pas fait fait soi-même la démarche de conception.

A l'opposé, étant issu d'une culture 'programmation structurée', donc basée sur les algorithmes, le pseudo-code et le Pascal, mes projets en assembleur étaient écrits de façon structurée, ce qui m'avais valu le surnom de 'compilateur humain' que j'assumais totalement.

Devant les difficultés induites par la culture du saut, une reflexion universitaire a été menée pour trouver une façon plus rationnelle de décrire les comportements et de les coder. Les travaux les plus aboutis sont ceux de Klaus Wirth qui ont débouchés sur les principes de la programmation structurée

structures de données
structures de code
- procédures avec ou sans paramètres
- fonctions avec ou sans paramètres et retour
- structures de décision (IF ELSE SELECT)
- structures d'itération (REPEAT UNTIL WHILE FOR)

et l'élaboration de langages basés sur ces principes (Algol ou Algorithm Language et Pascal).

Le principe est de penser en terme d'action conditionnelle et non plus en terme de saut conditionnelle. De plus, la séparation claire entre saut avant (décisions) et saut arrière (itération) permet une vision bien plus claire du code. On se rapproche de concepts plus humains, ce qui autorise une réalisation proche de la pensée humaine Je rappelle le processus :

Définition
- exprimer le besoin
Conception
1. traduire le besoin en terme de comportement en utilisant des phrases simples et claires (algorithme textuel)
2. traduire le comportement en pseudo-langage (algorithme formel).
Codage et tests
- ensuite, tous les langages 3G ou plus disposant des instructions permettant de réaliser les structures de code, il devient extrêmement simple de passer de la conception au codage.

On voit donc que la notion de saut n'est plus compatible avec le mode de pensée mis en oeuvre de nos jours que ce soit au niveau de la conception ou du codage. Cependant, la plupart des langages 3G ont conservé l'instruction goto, mais avec des réserves d'usage, notamment la portée, qui est locale au bloc. Malgré cette restriction, une utilisation abusive peut mener à du code inextricable, notamment en raison des sauts arrières.

Divers articles ont été écrits sur le sujet, le plus célèbre étant celui de Dijkstra : www.acm.org/classics/oct95/

Il en ressort que l'usage de goto est fortement déconseillé, notamment en arrière (itérations).

Par contre, un usage maitrisé est possible pour

optimiser certains algorithmes
traiter les erreurs

ces cas sont rares et doivent être documentés (surtout le premier)

**DaZumba** · 20/12/2006, 17h03

Envoyé par Emmanuel Delahaye

La portabilité n'est pas en cause. ...

Impressionnant ! Tu profites du forum pour rediger tes cours de formation ?

**Emmanuel Delahaye** · 20/12/2006, 17h44

Envoyé par DaZumba

Impressionnant ! Tu profites du forum pour rediger tes cours de formation ?

Chut !

**XxghostxX** · 22/12/2006, 11h33

merci pour ta reponse exaustive emmanuel lol

l'article fournit par le lien est trés interressant

j'ai réalisé une heuristique de colaration d'un graphe en c qui as des resultat assé correct pour un tp je me demande aprés tes explication si sa vitesse d'execution ne pourrait etre ameliorée par l'utilisation de goto " vas savoir"

merci encore