1 != 1 - créer un bug ?

niahoo, ton raisonnement est correct. Et oui, 9,999999999.... = 10 . En fait, tout ce qui se termine par 9 à l'infini, peut être remplacé par le "1" correspondant...

3,12399999999999999....
=
3,124


attention, tu n'as pas montré que 1 n'est pas égal à 1 ... tu as montré que 0.99999.... est égal à 1 . Il y a deux manière d'écrire le nombre entier 1 en écriture décimale : 1,0000.... et 0,9999.... ;)

oui, le problème c'est j'aime dire que c'est comme le mot pollution. C'est complètement vague comme notion.

Par contre en maths c'est "quelque chose" de précis (ou plutot c'est plusieurs notions différentes). Il y a par exemple le fait qu'il y a une infinité de chiffres après la virgule (ça c'est précis ! et on peut avoir des résultats avec, par exemple le précédent). Il y a l"infiniment grand" dans les limites et les études de fonctions (niveau lycée). etc...

Simplement parler de "l'infini", je suis d'accord avec toi, n'est qu'une notion abstraite plus ou moins philosophique. Mais sinon, dans les applications elle est tout à fait utilisable : l'infini dont je te parlais des études de fonctions est déjà implémenté en programmation via le standard IEEE des nombres à virgule (flottante) habituels sur les ordinateurs.
Si tu fais un calcul qui donne un nombre trop grand, la valeur symbolique "Inf" est retournée. Elle réagit grosso-modo comme les limites (je ne sais pas si tu as vu ça où si tu t'en rappelles ? )

tu connais des applications mathématiques du 1 écrit 0,9999~ ?
non. Ce serait plutôt un résultat en soit, une simple curiosité et un prétexte de réflexion sur "qu'est-ce qu'un nombre"... c'est un révélateur du problème que pose l'écriture décimale (et "qu'est ce que l'écriture décimale" d'un nombre? )
On peut retrouver ça plus simplement :
1/3 + 1/3 + 1/3 = 3/3 = 1
0.333... + 0.333... + 0.333 = 0.999...


Et sinon, par rapport à ta question de départ, c'est justement dans les float et leur approximation qu'il y a une grande source de bugs possibles.

j'ai fait un petit programme pour illustrer mes propos :

//------------------------------------------------
#include <iostream>
#include <string>

using namespace std;


int main(int argc, char *argv[])
{

    float a=2.0, b=2.00001;
    cout << "Une erreur d'arrondi plutot importante :" << endl;
    cout << "a=" << a << endl << "b = " << b << endl;
    cout << "b-a = " << b-a << endl;
    cout << "100000000.0*(b-a) = " << 100000000.0*(b-a) << endl;
    cout << "Je doute que la banque ou le magasin apprecie!";
    cout << endl << endl << endl;
    
    
    float c=5000.0;
    float d=c;
    float petit = 0.000001;
    cout << "Voici un petit nombre : " << petit << endl;
    cout << "1'000'000'000 * petit = " << 1000000000*petit << endl;
    cout << "c = " << c << endl;
    cout << "Ajout de 1'000'000'000 de fois petit dans c ... " << endl;
    for (int i=0; i<1000000000; i++) {
        // j'ajoute 1 milliard de fois un millionième.
        // en tout ça fait que j'ai ajouté 1000
        // le résultat devrait être 500001000
        d = d + petit;
    }
    cout << "d = "<<d << endl;
    cout << "c == d    :    " << ((c==d)?"vrai!":"faux!") << endl; 
        
    
    //fin
    cin >> a;
    return 0;
}

pour le commentaire, désolé, j'avais mis autre chose avant, et j'ai oublié de modifier, tu as bien corrigé.



et sinon ça peut paraître un peu tiré par les cheveux mon truc d'ajouter plein de fois 0...
pourtant tu as bien vu, mon nombre n'est pas 0.
Et en pratique lors de calcul scientifique, ou économique, etc., il arrive souvent de devoir ajouter un très grand nombre de valeurs entre elles. Mais si tu as plein de petites et une relativement grosse, peu importe le nombre de petite que tu ajoutes, la grosse aura "mangé" les autres si tu ne fais pas attention. Même si à la fin tu aurais été censé avoir un bien plus gros résultat.