Jusqu'à présent, dans cette série de didacticiels, nous avons expliqué comment créer et exécuter un programme C de base, ce que sont les préprocesseurs, ainsi que les bases des variables. Maintenant, approfondissons un peu les variables et discutons de l'aspect mémoire.
En supposant que vous ayez déjà parcouru tous nos didacticiels jusqu'à présent (ou que vous ayez les connaissances de base nécessaires pour comprendre ce didacticiel), commençons par un exemple de code simple que nous avons utilisé dans l'un de nos didacticiels précédents.
#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;
}
Ce programme, comme vous pouvez le voir, calcule la factorielle d'un nombre entré par un utilisateur.
Maintenant, pour des nombres entiers plus petits comme 5 ou 6, ce programme fonctionnera bien - il affichera correctement le résultat factoriel. Mais, disons que vous l'essayez pour le numéro 13. Voici le résultat que vous obtiendrez :
Factorial of 13 is 1932053504
Mais ce n'est pas vrai car le factoriel de 13 est 6227020800. Alors, naturellement, la question est pourquoi notre programme a donné une mauvaise réponse ? Eh bien, la réponse réside dans la quantité de mémoire qu'une variable int occupe dans le système.
Dans la plupart des systèmes actuels, int occupe 4 octets (ou 32 bits) de mémoire. Notez que vous pouvez utiliser la ligne suivante dans votre programme pour connaître le nombre d'octets occupés par int sur votre système.
printf("\n int size in bytes is: %d ", sizeof (int)); Et comme une variable int peut également stocker des valeurs négatives, la plage de valeurs qu'elle peut stocker varie de -2 147 483 648 à 2 147 483 647.
Maintenant, puisque la factorielle de 13 est bien supérieure à la valeur maximale qu'une variable int peut contenir, notre programme donne une mauvaise sortie. La seule façon de corriger le programme est d'utiliser un type de variable capable de contenir 6227020800.
Si vous souhaitez conserver une valeur entière positive plus grande, vous pouvez utiliser "unsigned int", qui peut stocker des valeurs comprises entre 0 et 4 294 967 295 (en supposant que ce type de variables occupe 4 octets sur votre système). Mais ici, même 'unsigned int' ne suffira pas car la factorielle de 13 dépasse sa capacité maximale.
Donc, notre sauveur ici serait "long long", qui occupe 8 octets ou 64 bits de mémoire. Voici donc le programme révisé :
#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;
}
La façon dont vous faites en sorte que printf ou scanf identifie une variable "long long" consiste à utiliser %lld (ou %I64d dans certains cas). Voici la sortie que ce programme modifié produit :
Factorial of 13 is 6227020800
Ce qui est exact.
Donc, maintenant nous connaissons la limitation de 'int' et comment 'unsigned int' et 'long long' peuvent être utilisés pour surmonter cela. Gardez à l'esprit que 'long; ' est également un type variable mais sur la plupart des systèmes actuels, int et long occupent 4 octets.
Oh, et oui, alors que 'int', 'unsigned int' et 'long long' sont pour les entiers, il y a 'float' et 'double' pour les nombres à virgule flottante. Float est de 32 bits et a 7 chiffres décimaux de précision, tandis que double est de 64 bits et a 15 chiffres décimaux de précision.
La mention des nombres à virgule flottante m'amène à un autre point important ici. C'est lié à la division. Prenons un simple exemple de code C pour comprendre cela.
int main (void)
{
int a=5, b=10;
printf("\n a/b is %d", a/b);
return 0;
}
Donc ce programme ne fait rien, mais divise a par b, ou 5 par 10.
Dans la vraie vie, si vous demandez à quelqu'un le résultat de 5/10, vous obtiendrez 0,5 comme réponse dans la majorité des cas. Mais ici, la réponse sera zéro (0). La raison étant que 'a' et 'b' sont des entiers, et donc le résultat de leur division sera également considéré comme un entier, et donc la partie flottante sera ignorée.
Pour préserver la partie flottante, vous devrez vous assurer que 'a' et 'b' sont des variables à virgule flottante.
#include <stdio.h>
int main (void)
{
float a=5, b=10;
printf("\n a/b is %f", a/b);
return 0;
}
Dans ce cas, la sortie serait de 0,5.
Dans ce didacticiel, nous avons discuté de la taille des variables et de son incidence sur le stockage des valeurs. J'espère que vous avez une bonne idée de comment et quand utiliser int, unsigned int, long long, float et double. Dans le prochain didacticiel, nous aborderons les variables de type caractère ainsi que les tableaux.