Reken met types

[Damon Dike]

Ik heb de volgende opgave:
y = c/b
Met deze declaraties:
double y = 0,71
int c = 10
int b = 3

Dat geeft het volgende:
int / int => int

Volgens mijn uitwerkingen zou dan de uitkomst 3,33333... moeten zijn, maar deze uitkomst zou niet in de double passen.

Nu heb ik het volgende vragen:
- Als je een int als uitkomst hebt kun je toch nooit 3,33333... als uitkomst krijgen, want die worden afgekapt dus zou, volgens mij de uitkomst 3 moeten zijn.
- Waarom past de int niet in de double?? Een double heeft 8 bytes, een int maar 4 dat zou toch gewoon moeten passen. En dan zou volgens mij de uitkomst 3,0000... moeten zijn.

 

[Arjan B]

- Als je een int als uitkomst hebt kun je toch nooit 3,33333... als uitkomst krijgen, want die worden afgekapt dus zou, volgens mij de uitkomst 3 moeten zijn

Klopt helemaal.

- Waarom past de int niet in de double?? Een double heeft 8 bytes, een int maar 4 dat zou toch gewoon moeten passen. En dan zou volgens mij de uitkomst 3,0000... moeten zijn.

Hoezo "past hij niet"? Ik denk dat je bedoelt dat de types gewoon niet overeenkomen en je daarom een waarschuwing/foutmelding van je compiler krijgt.

Wat je zou kunnen doen is van de integers doubles maken:

double a = 10;
double b = 3;
double y;
y = a/b;

Of de de integers casten naar doubles:

int a = 10;
int b = 3;
double y;
y = (double)a/(double)b;

 

[Johantrax]

- Waarom past de int niet in de double?? Een double heeft 8 bytes, een int maar 4 dat zou toch gewoon moeten passen. En dan zou volgens mij de uitkomst 3,0000... moeten zijn.

Een integer past wel degelijk in een double, en wel om de exacte reden die je aanhaalt. Omdat een double (en zijn naam zegt het eigenlijk al) dubbel zo groot is als een integer. Even terzijde: een integer is niet altijd 4 bytes, dat is wel zo op bijna alle pc's en 32-bit systemen, maar bij microcontrollers bvb is een integer vrij frequent slechts 2bytes. Het is echter wel altijd zo dat een double het dubbel is van een integer.

Dus waarom krijg je de 'correcte' uitkomst dan niet? De double is toch groot genoeg?
De reden daarvoor zit in de werking van de taal.
Wat er gebeurd wanneer jij schrijft dat y = a / b;
1. Getal (integer) a, wordt gedeeld door (integer) b. Aangezien beide variabelen van het type integer zijn, wordt een integerdeling uitgevoerd, en het resultaat een integer, en dus afgekapt.
2. Pas na de berekening van een rechterlid gedaan is, wordt die aan het linkerlid (de variabele y) toegekend. Y is en blijft een double, maar wat erin wordt gestoken is de uitkomst van de vorige stap, en dat is de reeds afgekapte uitkomst van de integerdeling.

De oplossing is te vinden bij wat Arjan reeds zei:
Ofwel pas je de types van je variabelen aan, zodat deze al van in het begin double zijn. Een mogelijk nadeel is dat ze dan wel meer plaats innemen, hoewel dat voor de meeste normale programma's op normale computers al een tijdje niet echt een probleem meer is, gezien de gigantische geheugenruimtes.
Ofwel zorg je ervoor dat minstens 1 van de 2 integers tijdens de berekening als double wordt behandeld. En dat kan met typecasting, zoals in Arjan's laatste voorbeeld (maar slechts 1 van de 2 conversies is daar nodig).

@Arjan: Met de gegeven code krijg je geen waarschuwingen over het niet overeenkomen van de types, zelfs niet met de compileroptie om alle warnings te tonen (-Wall), aangezien er bij deze impliciete conversie geen gegevens verloren gaan. Een variabele van een klein type krijgt gewoon meer plaats in het grote type.
Als je wil kan je deze waarschijnlijk wel krijgen door met -pedantic te compileren, maar Pedantic-mode is in 99.99% (en meer) van de gevallen zwaar overbodige wachttijd zonder meerwaarde.