Discussion :

[doudou2152]

Je ne comprend pas hier ce programme marchait nikel sous code block et ce matin plus rien a faire il plante.

Est ce que quelqu'un sait pourquoi ?

[ram-0000]

Ce sont les joies de l'informatique

Tu pourrais nous aider un peu en :

• nous disant ce que devrait faire ton programme
• nous donnant le message d'erreur affiché (s'il y en a un)
• nous indiquant comment reproduire le problème (puisqu'il faut que l'utilisateur saisisse des données)
• indentant un peu mieux ton code de manière à le rendre plus facilement lisible

[droggo]

Dyi,

Je dirais même plus : il s'agit forcément d'un bug.

[orfix]

Avant d'aller plus loin, est-ce que ceci ne te choques pas ?

Code :

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

1
2
3
4
5
6
7
  char		buf[0];
<...>
  read(0, buf, 2);
<...>
  char		buf[10];
<...>
      read(0, buf, 12);

[ram-0000]

Ca peut se compiler "char buf[0];"

Sans erreur

[orfix]

Oui c'est une extension gcc, similaire au flexible array member du C99, mais dans le cas présent ce n'est pas ce qu'il faut faire

Pour en savoir plus : Arrays of Length Zero

[ram-0000]

Oui c'est une extension gcc, similaire au flexible array member du C99

Je ne connaissais pas

mais dans le cas présent ce n'est pas ce qu'il faut faire

Clairement

[doudou2152]

Merci a tous, pour vos réponses, j'ai modifier un peu le programme et du coup j'ai çà :

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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
#include	<unistd.h>
#include	<stdlib.h>
#include	<string.h>
#include	<stdio.h>
 
#define		FAILURE 0
#define		SUCCESS 1
 
int		*make_int_tab(char **tab, int *nb);
void		swap(int *nb, int idx, int pivot);
int		check_order(int *nb);
int		*quicksort_in(int *nb, int max);
void		epur(char *buf);
void		*xmalloc(int size);
 
/*Permet d'afficher le tableau trier*/
 
void		aff_nb(int *nb)
{
  int		i;
 
  i = 0;
  while (nb[i])
    {
      printf("-->  %d\n", nb[i]);
      i++;
    }
}
 
/*transforme un tableau de caractere en un tableau de nombre*/
 
int		*make_int_tab(char **tab, int *nb)
{
  int		i;
 
  i = 0;
  while (tab[i])
    {
      nb[i] = atoi(tab[i]);
      i++;
    }
  return (nb);
}
 
/*permet d'interchanger deux cases du tableau de nombre*/
 
void		swap(int *nb, int idx, int pivot)
{
  int		save;
 
  save = nb[idx];
  nb[idx] = nb[pivot];
  nb[pivot] = save;
}
 
/*verifie l'ordre du tableau */
 
int		check_order(int *nb)
{
  int		i;
 
  i = -1;
  while (nb[++i])
    {
      if (nb[i + 1] && nb[i] > nb[i + 1])
	return (FAILURE);
    }
  return (SUCCESS);
}
 
int		check_order2(int *nb)
{
  int		i;
 
  i = -1;
  while (nb[++i])
    {
      if (nb[i + 1] && nb[i] < nb[i + 1])
	return (FAILURE);
    }
  return (SUCCESS);
}
 
int		*quicksort_de(int *nb, int max)
{
  int		pivot;
  int		idx;
 
  idx = 0;
  pivot = max;
  while (check_order2(nb) == FAILURE)
    {
      if (idx == pivot)
	{
	  pivot--;
	  idx = 0;
	}
      if (nb[idx] < nb[pivot])
	  swap(nb, idx, pivot);
      idx++;
    }
  return (nb);
}
 
/*trie le tableaud de nombre dans l'ordre croissant*/
 
int		*quicksort_in(int *nb, int max)
{
  int		pivot;
  int		idx;
 
  idx = 0;
  pivot = max;
  while (check_order(nb) == FAILURE)
    {
      if (idx == pivot)
	{
	  pivot--;
	  idx = 0;
	}
      if (nb[idx] > nb[pivot])
	  swap(nb, idx, pivot);
      idx++;
    }
  return (nb);
}
 
/*permet de recuperer la taille d'un tableau*/
 
int		lentab(char **tab)
{
  int		i;
  int		count;
 
  i = 0;
  count = 0;
  while (tab[i])
    i++;
  return (i);
}
 
/*demande a l'utilisateur l'ordre de trie*/
 
int		type_order()
{
  char		buf[3];
 
  printf("Si vous effectuez un tri dans l'ordre croissant taper 1, sinon pour trier dans l'ordre decroissant taper 2\n");
  scanf("%s", buf);
  return (atoi(buf));
}
 
/*fonction de dichotomi*/
 
void		dichotomi(int *nb)
{
  char		buf[10];
  int		nb_find;
  int		count;
  int		i;
 
  i = -1;
  count = 0;
  while (buf[0] != 'q')
    {
      printf("Quel chiffre rechercher vous? Appuyer sur Q pour quitter\n");
      scanf("%s", buf);
      if (buf[0] != 'q')
	{
	  nb_find = atoi(buf);
	  while (nb[++i])
	    if(nb[i] == nb_find)
	      count++;
	  if (count == 0)
	    printf("Le tableau ne contient pas le nombre %d\n", nb_find);
	  else
	    printf("Le tableau contient %d le nombre %d\n", count, nb_find);
	  count = 0;
	  i = 0;
	}
    }
}
 
/*premet de connaitre le nombre d'element du tableau de caractere*/
 
int		nb_word(char *s, int i)
{
  int		idx;
  int		count;
 
  idx = -1;
  count = 0;
  while (++idx < i)
    {
      if (s[idx])
	count++;
      while (s[idx] != '\0')
	idx++;
    }
  count++;
  return (count);
}
 
void		*xmalloc(int size)
{
  void		*new;
 
  if((new = malloc(size)) == NULL)
    exit(1);
   return (new);
}
 
 
 
/*creer un tableau de caractere a partir d'une chaine. Ce tableau sera ensuite transformer en tableau de nombre (int *)*/
 
char		**my_str_to_wordtab(char *s, char **tab)
{
  int		i;
  int		n;
  int		t;
 
  i = -1;
  n = -1;
  t = 0;
  while (s[++i])
    if (s[i] == ' ' || s[i] == '\t')
      s[i] = '\0';
  tab = xmalloc(nb_word(s, i) * sizeof(*tab));
  while (++n < i)
    {
      if (s[n])
	tab[t++] = &s[n];
      while (s[n] != '\0')
	n++;
    }
  tab[t] = NULL;
  return (tab);
}
 
/*fonction principale*/
 
int		main()
{
  int		flag;
  char		buf[2048];
  char		**tab;
  int		*nb;
  int		len;
 
  printf("Veuillez entrer les nombres souhaitees\n");
  memset(buf, '\0', 2048);
  read(0, buf, 2048);
  tab = my_str_to_wordtab(buf, tab);
  flag = type_order();
  len = lentab(tab);
  nb = xmalloc((len + 2) * sizeof(*nb));
  nb = make_int_tab(tab, nb);
  if (flag == 1)
    nb = quicksort_in(nb, len - 1);
  else if (flag == 2)
    nb = quicksort_de(nb, len - 1);
  aff_nb(nb);
  dichotomi(nb);
  return (0);
}

Je souhaite en fait avec mon programme rentrer une série de valeur qu'ensuite je range dans l'ordre dans l'ordre croissant ou décroissant à l'aide de quicksort. je cherche ensuite le nombre d'occurence d'un nombre à l'aide de la recherche dichotomique.

néanmoins, lorsque j'ai rentré ma série de valeur et que donc je tape 1 ou 2 pour ranger dans l'ordre croissant ou décroissant le programme bug et donc impossible de continuer.

Si vous avez des questions n'hésiter pas j'aimerais vraiment réussir a faire marcher mon programm c'est mon projet ^^

[doudou2152]

J'ai un autre problème aussi car je suis sur un autre programme. Il commence comme ceci

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
 
int main()
 
{
 
  int recommencer=1;
  do
  {
 
    int nombre;                             //nombre decimal rentre
    int i=7, bin[8]={0};
    int j=0;
    int conv;                               //type de convertion
    int dec=0;
    float puis;                             //puissance de 10
    int X=7;                                //valeur du nombre de bits
    float valeur;                           //nombre binaire rentre
    int a;
    int b=0, tab[8]={0};
    int d=7;
    int e=0;
    char lettre;
    int nb;
    int f;
    char salut;
 
 
 
 
    printf("\n\n");
    printf("\tConversion Decimal-Binaire --> tapez 1 \n\tConversion Binaire-Decimal --> tapez 2 \t\t --> ");
    scanf("%d",&conv);
    printf("\n\n\n");

Dans le cas où on tape un autre chiffre que un ou deux le programme me demande si je veux recommencer mais si je met une lettre il bug complètement. Je fais comment pour pas que çà arrive et pour recommencer le programme svp

[droggo]

Qia,

Il faut être plus strict dans ton travail.

Tu cherches à entrer une lettre dans une variable de type int.

Si tu veux entrer une valeur en hexadécimal, il faut lire une chaine de caractères, PUIS la convertir en valeur entière.

[doudou2152]

Justement, il ne faut pas taper de lettre mais comme c'est un projet je suis sur que le professeur va vérifier en tapant une lettre voir si on a penser a tout pour pas planter le programme tu comprend ?

[gangsoleil]

Bonjour,

Dans le cas où on tape un autre chiffre que un ou deux le programme me demande si je veux recommencer mais si je met une lettre il bug complètement. Je fais comment pour pas que çà arrive et pour recommencer le programme svp

La solution est tres simple : tu arretes d'utiliser scanf, qui doit etre reservee pour les entrees formatees, et tu utilises un code qui ne plante pas quel que soit le caractere.

Tutoriel a lire : http://emmanuel-delahaye.developpez....ees-solides-c/