Discussion :

[margot346]

Bonjour je débute (2jours) en programmation et j'ai choisi C pour commencer
Après avoir écrit le premier programme pour capter scanf et print je me pose la question de l'utilité de int alors que float accepte les nombres entiers également.

Pouvez vous m'eclairer un peu ?

Merci !!!!

[Bktero]

Bonjour,

La précision : 3 dans un float sera peut-être égal à 3.000000000001.
La vitesse : les calculs avec des flottants sont généralement beaucoup plus lents que les calculs avec les entiers.
La sémantique : si tu travailles avec des entiers, tu utilises int. Si tu travailles avec des flottants, tu utilises float.

j'ai choisi C pour commencer

C'est un choix ^^ Sache que c'est un langage assez compliqué, avec beaucoup de zones "d'ombre", alors ne te décourage pas !

Si tu cherches un langage plus simple, tu pourras un de ces jours utiliser Python. Mais ceci est une autre histoire.

[margot346]

Merci beaucoup pour ta réponse rapide et claire
Je vais essayer de pas me décourager ...

[Sve@r]

Si tu cherches un langage plus simple, et quasiment tout aussi puissant, tu pourras un de ces jours utiliser Python

[Bktero]

Je parlais de précision des flottants hier, en voici un exemple en Python (sauf erreur en math de ma part, mais Sve@r nous le dire) :

>>> from math import log, log10 # log() est le log neperien
>>> log10(100)
2.0
>>> log(100) / log(10)
2.0
>>> log10(1000)
3.0
>>> log(1000) / log(10)
2.9999999999999996

[Sve@r]

Je parlais de précision des flottants hier, en voici un exemple en Python (sauf erreur en math de ma part, mais Sve@r nous le dire) :

Oh on a plus simple en tapant simplement des nombres et en voyant comment ils sont convertis

>>> 2.96
2.96
>>> 2.123
2.1230000000000002

Ce problème est connu et il est inhérent à la façon dont la partie décimale d'un nombre est convertie en binaire. Pour ce, on la multiplie par 2 et on enlève ce qui dépasse "1". Et on s'arrête quand la partie restante tombe à zéro.
Ce qui peut arriver... (avec 0.625)
0.625 x 2 = 1.25 => on garde "1" et on laisse 0.25
0.25 x 2 = 0.5 => on garde "0" et on laisse 0.5
0.5 x 2 = 1.0 => on garde "1" et il reste 0 => c'est fini => 0.625 se codera en binaire 101

... tout comme ne pas arriver (avec par exemple 0.33)
0.33 x 2 = 0.66 => 0
0.66 x 2 = 1.32 => 1
0.32 x 2 = 0.64 => 0
0.64 x 2 = 1.28 => 1
0.28 x 2 = 0.56 => 0
0.56 x 2 = 1.12 => 1
0.12 x 2 = 0.24 => 0
0.24 x 2 = 0.48 => 0
0.48 x 2 = 0.96 => 0
0.96 x 2 = 1.92 => 1
0.92 x 2 = 1.84 => 1
0.84 x 2 = 1.68 => 1
0.68 x 2 = 1.36 => 1
0.36 x 2 = 0.72 => 0
0.72 x 2 = 1.44 => 1
0.44 x 2 = 0.88 => 0
0.88 x 2 = 1.76 => 1
0.76 x 2 = 1.32 => 1
0.32 x 2 = 0.64 => 1
A partir de là on voit que ça ne peut plus s'arrêter. Et donc 0.33 se codera en binaire 101000111101011 mais 101000111101011 décodé ne fera pas exactement 0.33

>>> 0.33
0.33000000000000002

Et si on ajoute en plus le découpage en mantisse et exposant...