Version imprimable
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 !!!!:D
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.
C'est un choix ^^ Sache que c'est un langage assez compliqué, avec beaucoup de zones "d'ombre", alors ne te décourage pas ! :ccool:Citation:
j'ai choisi C pour commencer
Si tu cherches un langage plus simple, tu pourras un de ces jours utiliser Python. Mais ceci est une autre histoire.
Merci beaucoup pour ta réponse rapide et claire
Je vais essayer de pas me décourager ...
:lahola::lahola::lahola:Citation:
Envoyé par Bktero
:mouarf:
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) :
Citation:
>>> 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
Oh on a plus simple en tapant simplement des nombres et en voyant comment ils sont convertisCitation:
Envoyé par Bktero
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.Citation:
>>> 2.96
2.96
>>> 2.123
2.1230000000000002
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
Et si on ajoute en plus le découpage en mantisse et exposant...Citation:
>>> 0.33
0.33000000000000002