Hjälp med ett C-program!

Du har precis lärt dig orsaken varför program som jobbar med pengar aldrig använder flyttal

Talet 0,03 kan inte representeras exakt med den metod din dator använder, således blir jämförelsen som görs i while-loopen inte helt väldefinierad i fallet när något borde vara exakt 0,03.

Ett sätt att lösa problemet är att bara räkna med hela ören för att sedan enbart konvertera till flyttal vid t.ex. presentation.

#include <stdio.h>
#define SLUTSUMMA 3 /*Hur många dagar tar det att tjäna 3 ören?? */

static float ore_to_kr(unsigned ore)
    {
    return ore / 100.0;
    }

int main()
    {
    unsigned dag = 0;
    unsigned sum = 0, lon = 1;

    while (sum < SLUTSUMMA)
        {
        sum = sum + lon;
        lon = 2*lon;
        dag++;
        }
    printf("Han måste jobba %d dagar för %.2f kr.\n", dag, ore_to_kr(SLUTSUMMA));
    }

Detta är vad ditt program håller i loopens andra varv med flyttal

(gdb) p sum
$2 = 0.0299999993
(gdb) p dag
$3 = 2

Här ser vi alltså att "sum" inte riktigt är 0,03 utan det är något som är marginellt mindre vilket betyder att "sum < SLUTSUMMA" blir falskt när "dag == 2".

Problemet är att 0,03 inte kan skrivas exakt som en summa av tal på formen B(1) * 1 / 2 + B(2) * 1 / 4 + ... B(N) * 1 / 2^N. Här är då B(N) endera noll eller ett (om biten i den positionen i datorns flyttalsregister är tänd eller släckt). Det är så din dator i grunden representerar flyttal (har kapat en del detaljer).

Lite samma sak som att 1 / 3 är exakt men det går inte att beskriva det exakt med ett decimaltal, man får som närmast 0,33333...

Sällan ett problem i isolation, men om du gör exakta jämförelser eller än mer om du utför väldigt många beräkningar så kan det lilla avrundningsfel som inträffar vid konverteringen i vissa fall växa sig rätt stor efter ett gäng beräkningssteg om det vill sig illa.

Så att räkna ören med heltal är verkligen exakt, det motsvarar 1 / 3 representationen och sedan matematik med bråk medan flyttal är lite förenklat som att du räknar med decimaltal (inte en hel perfekt jämförelse, men nära nog hoppas jag).

@jason83: nu börjar du gräva dig ner i ett väldigt djupt kaninhål

Två saker som är kritiska att förstå här:

1.
När man får en oexakt representation av något är den i hälften av fallen större och i hälften av fallen mindre än det exakta värdet.

Jämför med 1 / 3 som alltid är större än 0,3333... oavsett hur många treor jag smackar på. För 2 / 3 gäller det omvända, blir ju avrundat alltid en sjua i sista positionen 0,6666666667.

2. jämförelser mot en flyttalskonstant kommer inte vara en jämförelse mellan två tal med typen "float", utan det kommer vara en jämförelse mellan "double". När man byter typ finns risk att avrundningsfelet slår åt andra hållet, vilket är precis vad som händer här.

Även detta get "rätt" svar

#include <stdio.h>
#define SLUTSUMMA 0.03 /*Hur många dagar tar det att tjäna 3 ören?? */

int main()
    {
    int dag = 0;
    double sum = 0, lon = 0.01;

    while (sum < SLUTSUMMA)
        {
        sum = sum + lon;
        lon = 2*lon;
        dag++;
        }

    printf("Han måste jobba %d dagar för %.2f kr.\n", dag, SLUTSUMMA);
    }

Även detta blir "rätt" och är precis det fall du nu har i praktiken

#include <stdio.h>
#define SLUTSUMMA 0.03 /*Hur många dagar tar det att tjäna 3 ören?? */

int main()
    {
    int dag = 0;
    float sum = 0, lon = 0.01;

    while (sum < (float)SLUTSUMMA)
        {
        sum = sum + lon;
        lon = 2*lon;
        dag++;
        }

    printf("Han måste jobba %d dagar för %.2f kr.\n", dag, SLUTSUMMA);
    }