In deze leerprogramma serie hebben we tot nu toe besproken hoe je een basis C programma maakt en uitvoert, wat preprocessors zijn, en ook de grondbeginselen van variabelen. Laten we nu wat dieper ingaan op variabelen en het geheugenaspect bespreken.

Ervan uitgaande dat je al onze leerprogramma’s tot nu toe al hebt doorgenomen (of dat je de basiskennis hebt die nodig is om deze leerprogramma’s te begrijpen), laten we beginnen met een eenvoudig code voorbeeld dat we in een van onze vorige leerprogramma’s gebruikten.

#include <stdio.h>

int main (void)
{
 int num = 0, temp=0;
 printf("\n Enter a positive integer: ");
 scanf("%d", &num);
 temp = num;
 int result = 1;
 while (temp > 0)
 {
    result = result * temp;
    temp = temp -1;
 }

 printf("\n Factorial of %d is %d\n", num, result);
 
 return 0;
}

Dit programma berekent, zoals je ziet, de factorie van een door een gebruiker ingevoerd getal.

Nu, voor kleinere gehele getallen zoals 5 of 6 werkt dit programma prima – het geeft het factorie resultaat correct weer. Maar, stel dat je het uitprobeert voor het getal 13. Hier is het resultaat dat je krijgt:

Factorial of 13 is 1932053504

Maar dat klopt niet want de factorie van 13 is6227020800. De vraag is dus natuurlijk waarom ons programma een verkeerd antwoord gaf? Wel, het antwoord ligt in de hoeveelheid geheugen die een int variabele inneemt in het systeem.

In de meeste systemen neemt int tegenwoordig 4 bytes (of 32 bits) geheugen in. Merk op dat je de volgende regel in je programma kunt gebruiken om te weten hoeveel bytes int op je systeem inneemt.

printf("\n int size in bytes is: %d ", sizeof (int));

En omdat een int variabele ook negatieve waarden kan opslaan, varieert het bereik van waarden die hij kan opslaan van-2.147.483.648 tot 2.147.483.647.

Nu, omdat factorie van 13 veel groter is dan de maximale waarde die een int variabele kan bevatten, geeft ons programma een verkeerde output. De enige manier om het programma gecorrigeerd te krijgen is een variabel type te gebruiken dat de capaciteit heeft om6227020800 vast te houden.

Wil je een grotere positieve gehele waarde vasthouden, dan kun je ‘unsigned int’ gebruiken, dat waarden van0 tot 4.294.967.295 kan opslaan (ervan uitgaande dat dit type variabelen op je systeem 4 bytes in beslag neemt). Maar hier zal zelfs ‘unsigned int’ niet volstaan, want de factor van 13 gaat zijn maximale capaciteit te boven.

Onze redder hier zou dus ‘long long,’ zijn, dat 8 bytes of 64 bits geheugen inneemt. Hier is dus het herziene programma:

#include <stdio.h>

int main (void)
{
 long long num = 0; long long temp=0;
 printf("\n Enter a positive integer: ");
 scanf("%d", &num);
 temp = num;
 long long result = 1;
 while (temp > 0)
 {
 result = result * temp;
 temp = temp -1;
 }

 printf("\n Factorial of %lld is %lld\n", num, result);
 
 return 0;
}

De manier waarop je printf of scanf een ‘long long’ variabele laat identificeren is door %lld te gebruiken (of in sommige gevallen %I64d). Hier is de uitvoer die dit aangepaste programma produceert:

Factorial of 13 is 6227020800 

Wat correct is.

We weten nu dus de beperking van ‘int’ en hoe ‘unsigned int’ en ‘long long’ gebruikt kunnen worden om dat te ondervangen. Bedenk dat ‘long; ‘ ook een variabel type is, maar dat op de meeste systemen tegenwoordig zowel int als long 4 bytes innemen.

O, en ja, terwijl ‘int’, ‘unsigned int’ en ‘long long’ voor gehele getallen zijn, zijn er ‘float’ en ‘double’ voor drijvende komma getallen. Float is 32 bits en heeft7 decimale cijfers van precisie, terwijl double 64 bits is en 15 decimale cijfers van precisie heeft.

De vermelding van floating point getallen brengt me op een ander belangrijk punt hier. Het heeft te maken met delen. Laten we een eenvoudig C code voorbeeld nemen om dit te begrijpen.

int main (void)
{
 int a=5, b=10;

 printf("\n a/b is %d", a/b);
 
 return 0;
}

Dit programma doet dus niets anders dan a delen door b, of 5 door 10.

In het echt, als je iemand de uitkomst van 5/10 vraagt, krijg je in de meeste gevallen 0.5 als antwoord. Maar hier zal het antwoord nul (0) zijn. De reden is dat zowel ‘a’ als ‘b’ gehele getallen zijn, en dus zal het resultaat van hun deling ook als een geheel getal beschouwd worden, en dus wordt het drijvende deel buiten beschouwing gelaten.

Om het drijvende deel te behouden, moet je ervoor zorgen dat zowel ‘a’ als ‘b’ variabelen met drijvende komma zijn.

#include <stdio.h>

int main (void)
{
 float a=5, b=10;

 printf("\n a/b is %f", a/b);
 
 return 0;
}

In dit geval zou de output 0.5 zijn.

Conclusie

In deze tutorial hebben we het gehad over variabele grootte en hoe die het opslaan van waarden beïnvloedt. Ik hoop dat je een goed idee gekregen hebt over hoe en wanneer je int, unsigned int, long long, float, en double gebruikt. In de volgende zelfstudie zullen we zowel variabelen van het karaktertype als arrays bespreken.