Discussion :

[erogan]

Bonjour, dans le cadre de mes études, je suis amené à créer ce petit programme qui, à partir d'un int, affiche un char. En révisant, je me suis apercue que mon programme était DÉGUELASSE, je l'ai donc refait, en passant par la récursive. Youpi, le programme ne tient plus qu'en une seule fonction et quelques lignes. Seulement, voilà le problème, le programme a une faille : lorsque je lui envoie -2 147 483 648, ce foutu prog me donne le résultat avec deux - : --2147483648.

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
 
void	putchar(char c)
{
  write(1, &c, 1);
}
 
void	put_nbr(int nb)
{
  int	nbr;
 
  if (nb > 0)
      nb = -nb;
  else
    putchar('-');
  nbr = nb % 10;
  putchar('n');
  if (nb < -9)
  	put_nbr(-nb / 10);
  putchar(-nbr + 48);
}
 
int	main()
{
  put_nbr(-2147483648);
  putchar('\n');
}

Une petite aide serait la bienvenue mais sans me donner la réponse s'il vous plaît ^^

En tout cas très beau travail de la part de vous tous et j'espère que j'aurais bientôt le niveau pour participer

[Neckara]

Bonjour,

Pourquoi avoir "réimplémenté" putchar, est-ce que cela fait parti de l'exercice ?

Code :

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

1
2
3
4
if (nb > 0)
      nb = -nb;
  else
    putchar('-');

Ne serait-ce pas plutôt :

Code :

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

1
2
3
4
5
if(nb < 0)
{
          nb = -nb;
          putchar('-');
}

?

EDIT : d'ailleurs je ne comprend pas pourquoi tu veux mettre ton nombre en négatif. N'est-ce pas plus simple de passer par des nombres positifs ?

Sinon au lieu de faire +48 ce qui n'est pas très clair, il vaut mieux faire : +'0'.

[erogan]

En faisant comme tu me le conseille, je me heurte à un overflow si je veux afficher le nombre -2147483648, car je ne peux pas le repasser en positif. C'est pour cela que je passe par le négatif.

Je ne comprend pas ta question sur la réimplémentation de putchar. Pourrais-tu être plus clair s'il-te-plaît ?

[erogan]

enfin... Le compilateur ne me préviens même pas de l'overflow, c'est juste que repasser -2147483648 en positfi n'est pas possible puisque les int s'arrêtent à la valeur 2147483648

[erogan]

ah oui, pardon,

Code :

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

putchar('n')

est une indication, pour savoir quand est-ce que mon programme me rajoute le -, ainsi j'obtiens :

Code :

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

-n-nnnnnnnnn2147483648

[erogan]

oui mais c'est bien sûr passer par une autre fonction, j'avais tellement envie de voir tout tenir le minimum de ligne que j'en avais ommis l'hypothèse de faire une autre fonction. Merci de me l'avoir rapellé. Résolu donc. Merci de ton aide.

[Sve@r]

enfin... Le compilateur ne me préviens même pas de l'overflow, c'est juste que repasser -2147483648 en positfi n'est pas possible puisque les int s'arrêtent à la valeur 2147483648

En fait, les int peuvent coder 4294967296 valeurs qui vont de -2147483648 à 2147483647 (à cause du 0 qui prend une position).
D'où effectivement le cas extrême quand ton nombre vaut pile poil -2147483648 lequel ne possède pas d'équivalent positif. Toutefois tu peux aussi réfléchir dans l'autre sens et considérer que tu n'as que des négatifs et faire le calcul sur la base de ce prédicat, quitte à convertir les positifs éventuels en négatifs. Là tu n'auras pas de problème de cas extrême à gérer...

[Médinoc]

Attends, mais oui!

On peut passer le nombre en non-signé dès qu'on l'a rendu positif!
Le -2147483648 signé et le 2147483648 ont la même représentation binaire...

Code C :

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
#ifdef _WIN32
	/*unistd.h n'existe pas*/
	#define _CRT_NONSTDC_NO_WARNINGS
	#include <io.h> /*pour write()*/
	#define STDOUT_FILENO 1
#else
	#include <unistd.h> /*pour STDOUT_FILENO*/
#endif
#include <limits.h> /*pour INT_MAX et INT_MIN*/
 
void putchar(char c)
{
	/*Ce n'est pas parce qu'on est à EPITA qu'on a le droit de coder comme un porc avec des nombres magiques.*/
	write(STDOUT_FILENO, &c, 1);
}
 
void put_unbr(unsigned int unb)
{
	unsigned int udigit = unb % 10u;
	if (unb > 9)
		put_unbr(unb / 10u);
	putchar((char)udigit + '0'); /*Voir commentaire dans putchar*/
}
 
void put_nbr(int nb)
{
	if (nb < 0)
	{
		putchar('-');
		nb = -nb;
	}
	put_unbr(nb);
}
 
int main(void)
{
	put_nbr(INT_MAX);
	putchar('\n');
 
	put_nbr(42);
	putchar('\n');
 
	put_nbr(1);
	putchar('\n');
 
	put_nbr(0);
	putchar('\n');
 
	put_nbr(-1);
	putchar('\n');
 
	put_nbr(-42);
	putchar('\n');
 
	put_nbr(INT_MIN);
	putchar('\n');
	return 0;
}

[Kirilenko]

Code :

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

/*unistd.h n'existe pas*/

Il y en a une implémentation sous Cygwin, et même sur MinGW.

En fait, les int peuvent coder 4294967296 valeurs qui vont de -2147483648 à 2147483647 (à cause du 0 qui prend une position).

Ce n'est pas parce qu'on code pour POSIX qu'on doit faire abstraction de la taille des types. Certes la représentation en complément à deux est garantie (selon mes souvenirs, ce n'est pas explicitement dit, mais on peut le déduire à partir de certaines données), mais un int n'est pas toujours codé sur 32 bits. Du fait des représentations en complément à 1 et signe et magnitude acceptées par la norme, il faudrait même parler de -2147483647.

[Neckara]

Déjà la vérification du signe ne doit se faire qu'une seule fois donc on peut envisager quelque chose comme :

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
void affiche_nombre(int val)
{
               unsigned int newVal = val;
               if(val < 0)
               {
                      putchar("-");
                      newVal = ~newVal; //équivalant à newVal = -val; car on code les signed sur du complément à 2.
               }
               m_affiche_nombre( newVal);
}
 
void m_affiche_nombre(unsigned int val)
{
//....
}

Sinon, tu peux faire le test du signe juste après avoir obtenu le premier chiffre et divisé ton nombre.

Pour putchar, c'est juste que cette fonction existe déjà :
http://man.developpez.com/man3/puts.3.php