In questa serie di tutorial finora, abbiamo discusso come creare ed eseguire un programma C di base, cosa sono i preprocessori e le basi delle variabili. Ora scaviamo un po' in profondità nelle variabili e discutiamo dell'aspetto della memoria.
Supponendo che tu abbia già seguito tutti i nostri tutorial finora (o che tu abbia le conoscenze di base necessarie per comprendere questo tutorial), iniziamo con un semplice esempio di codice che abbiamo usato in uno dei nostri tutorial precedenti.
#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;
}
Questo programma, come puoi vedere, calcola il fattoriale di un numero inserito da un utente.
Ora, per numeri interi più piccoli come 5 o 6, questo programma funzionerà bene:produrrà correttamente il risultato fattoriale. Ma supponiamo che tu lo provi per il numero 13. Ecco il risultato che otterrai:
Factorial of 13 is 1932053504
Ma non è vero perché il fattoriale di 13 è 6227020800. Quindi, naturalmente, la domanda è:perché il nostro programma ha dato una risposta sbagliata? Bene, la risposta sta nella quantità di memoria che occupa una variabile int nel sistema.
Nella maggior parte dei sistemi odierni, int occupa 4 byte (o 32 bit) di memoria. Nota che puoi utilizzare la seguente riga nel tuo programma per conoscere la quantità di byte che int occupa sul tuo sistema.
printf("\n int size in bytes is: %d ", sizeof (int)); E poiché una variabile int può memorizzare anche valori negativi, l'intervallo di valori che può memorizzare varia da -2.147.483.648 a 2.147.483.647.
Ora, poiché il fattoriale di 13 è molto maggiore del valore massimo che può contenere una variabile int, il nostro programma fornisce un output errato. L'unico modo per correggere il programma è utilizzare un tipo di variabile che abbia la capacità di contenere 6227020800.
Se desideri mantenere un valore intero positivo maggiore, puoi utilizzare "unsigned int", che può memorizzare valori compresi tra 0 e 4.294.967.295 (supponendo che questo tipo di variabili occupi 4 byte nel tuo sistema). Ma qui, anche 'unsigned int' non funzionerà poiché il fattoriale di 13 è oltre la sua capacità massima.
Quindi il nostro salvatore qui sarebbe "lungo lungo", che occupa 8 byte o 64 bit di memoria. Quindi ecco il programma rivisto:
#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;
}
Il modo in cui printf o scanf identifichi una variabile "long long" è utilizzando %lld (o %I64d in alcuni casi). Ecco l'output prodotto da questo programma modificato:
Factorial of 13 is 6227020800
Che è corretto.
Quindi, ora conosciamo il limite di "int" e come "unsigned int" e "long long" possono essere usati per superarlo. Tieni presente che è lungo; ' è anche un tipo variabile, ma oggi nella maggior parte dei sistemi sia int che long occupano 4 byte.
Oh, e sì, mentre 'int', 'unsigned int' e 'long long' sono per numeri interi, c'è 'float' e 'double' per numeri in virgola mobile. Float è a 32 bit e ha 7 cifre decimali di precisione, mentre double è a 64 bit e ha 15 cifre decimali di precisione.
La menzione dei numeri in virgola mobile mi porta a un altro punto importante qui. È legato alla divisione. Prendiamo un semplice esempio di codice C per capirlo.
int main (void)
{
int a=5, b=10;
printf("\n a/b is %d", a/b);
return 0;
}
Quindi questo programma non fa nulla, ma divide a per b, o 5 per 10.
Nella vita reale, se chiedi a qualcuno il risultato di 5/10, otterrai 0,5 come risposta nella maggior parte dei casi. Ma qui, la risposta sarà zero (0). Il motivo è che sia 'a' che 'b' sono interi, e quindi anche il risultato della loro divisione sarà considerato un intero, e quindi la parte mobile verrà ignorata.
Per preservare la parte mobile, dovrai assicurarti che sia 'a' che 'b' siano variabili in virgola mobile.
#include <stdio.h>
int main (void)
{
float a=5, b=10;
printf("\n a/b is %f", a/b);
return 0;
}
In questo caso, l'output sarebbe 0,5.
In questo tutorial, abbiamo discusso della dimensione variabile e di come influisce sull'archiviazione dei valori. Spero che tu abbia una buona idea su come e quando usare int, unsigned int, long long, float e double. Nel prossimo tutorial parleremo delle variabili del tipo di carattere e degli array.