Hasta ahora, en esta serie de tutoriales, hemos discutido cómo crear y ejecutar un programa básico en C, qué son los preprocesadores y los conceptos básicos de las variables. Ahora profundicemos un poco en las variables y discutamos el aspecto de la memoria.
Suponiendo que ya haya seguido todos nuestros tutoriales hasta el momento (o que tenga los conocimientos básicos necesarios para comprender este tutorial), comencemos con un ejemplo de código simple que usamos en uno de nuestros tutoriales anteriores.
#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;
}
Este programa, como puedes ver, calcula el factorial de un número ingresado por un usuario.
Ahora, para números enteros más pequeños como 5 o 6, este programa funcionará bien:generará correctamente el resultado factorial. Pero, digamos que lo intentas para el número 13. Este es el resultado que obtendrás:
Factorial of 13 is 1932053504
Pero eso no es cierto, ya que el factorial de 13 es 6227020800. Entonces, naturalmente, la pregunta es ¿por qué nuestro programa dio una respuesta incorrecta? Bueno, la respuesta está en la cantidad de memoria que ocupa una variable int en el sistema.
En la mayoría de los sistemas actuales, int ocupa 4 bytes (o 32 bits) de memoria. Tenga en cuenta que puede usar la siguiente línea en su programa para saber la cantidad de bytes que ocupa int en su sistema.
printf("\n int size in bytes is: %d ", sizeof (int)); Y dado que una variable int también puede almacenar valores negativos, el rango de valores que puede almacenar varía de -2,147,483,648 a 2,147,483,647.
Ahora, dado que el factorial de 13 es mucho mayor que el valor máximo que puede contener una variable int, nuestro programa da una salida incorrecta. La única forma de corregir el programa es usar un tipo de variable que tenga la capacidad de contener 6227020800.
Si desea mantener un valor entero positivo más grande, puede usar 'int sin signo', que puede almacenar valores que van desde 0 a 4,294,967,295 (suponiendo que este tipo de variables ocupan 4 bytes en su sistema). Pero aquí, incluso 'int sin firmar' no funcionará ya que el factorial de 13 está más allá de su capacidad máxima.
Así que nuestro salvador aquí sería 'largo largo', que ocupa 8 bytes o 64 bits de memoria. Así que aquí está el programa revisado:
#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 forma de hacer que printf o scanf identifiquen una variable 'larga larga' es usando %lld (o %I64d en algunos casos). Este es el resultado que produce este programa modificado:
Factorial of 13 is 6227020800
Lo cual es correcto.
Entonces, ahora conocemos la limitación de 'int' y cómo se pueden usar 'unsigned int' y 'long long' para superar eso. Tenga en cuenta que 'largo; ' también es un tipo variable, pero en la mayoría de los sistemas actuales, tanto int como long ocupan 4 bytes.
Ah, y sí, mientras que 'int', 'unsigned int' y 'long long' son para números enteros, hay 'float' y 'double' para números de punto flotante. Float es de 32 bits y tiene 7 dígitos decimales de precisión, mientras que double es de 64 bits y tiene 15 dígitos decimales de precisión.
La mención de los números de coma flotante me lleva a otro punto importante aquí. Está relacionado con la división. Tomemos un ejemplo de código C simple para entender esto.
int main (void)
{
int a=5, b=10;
printf("\n a/b is %d", a/b);
return 0;
}
Así que este programa no hace nada más que dividir a por b, o 5 por 10.
En la vida real, si le preguntas a alguien el resultado de 5/10, obtendrás 0,5 como respuesta en la mayoría de los casos. Pero aquí, la respuesta será cero (0). La razón es que tanto 'a' como 'b' son números enteros y, por lo tanto, el resultado de su división también se considerará como un número entero, por lo que la parte flotante no se tendrá en cuenta.
Para conservar la parte flotante, deberá asegurarse de que tanto 'a' como 'b' sean variables de coma flotante.
#include <stdio.h>
int main (void)
{
float a=5, b=10;
printf("\n a/b is %f", a/b);
return 0;
}
En este caso, la salida sería 0,5.
En este tutorial, discutimos sobre el tamaño variable y cómo afecta el almacenamiento de valores. Espero que hayas tenido una buena idea sobre cómo y cuándo usar int, int sin firmar, long long, float y double. En el próximo tutorial, analizaremos las variables de tipo de carácter, así como las matrices.