`` `C
#Include
#Include
#incluir
Factorial largo largo (int n) {
if (n <0) {
fprintf (stderr, "error:factorial no está definido para números negativos. \ n");
salida (1); // Salir con un código de error
}
if (n ==0) {
regresar 1;
}
resultado largo largo =1;
para (int i =1; i <=n; i ++) {
if (llong_max /resultado
salida (1);
}
resultado *=i;
}
resultado de retorno;
}
int main () {
int num;
printf ("Ingrese un entero no negativo:");
if (scanf ("%d", &num)! =1) {
fprintf (stderr, "Error:entrada inválida. \ n");
regresar 1; // Salir con un código de error
}
hecho largo largo =factorial (num);
printf ("factorial de %d =%lld \ n", num, hecho);
regresar 0;
}
`` `` ``
para compilar y ejecutar este código:
1. Guardar: Guarde el código como un archivo `.c` (por ejemplo,` Factorial.c`).
2. Compilar: Abra un terminal y use un compilador C (como GCC) para compilar el código:
`` `Bash
GCC Factorial.C -O Factorial
`` `` ``
3. Run: Ejecutar el programa compilado:
`` `Bash
./factorial
`` `` ``
El programa le pedirá que ingrese un número.
Mejoras y explicaciones:
* Manejo de errores: El código incluye cheques para:
* Entrada negativa: Maneja explícitamente la entrada negativa, que no se define para factoriales.
* desbordamiento: Evita el desbordamiento potencial al verificar si la siguiente multiplicación excedería el valor máximo que puede contener un entero 'largo' (`llong_max`). El uso de `Long Long` ofrece un rango más grande que` int` o `long`.
* Entrada no válida: Verifica si `scanf` lee con éxito un entero.
* `Long Long` Tipo de datos: El uso de `Long Long` proporciona un rango más amplio para el cálculo factorial, lo que le permite calcular factores de números más grandes antes de encontrar el desbordamiento. Sin embargo, incluso 'Long Long' tiene límites. Los factorales crecen extremadamente rápidamente.
* Borrar mensajes de error: Los mensajes de error informan al usuario sobre el problema específico encontrado.
* Códigos de salida: El programa utiliza códigos de salida apropiados (0 para el éxito, 1 para errores) que es una buena práctica para los programas que podrían llamarse desde otros scripts o programas.
Recuerde que los factoriales crecen increíblemente rápido. Incluso `Long Long` se desbordará para entradas relativamente pequeñas (¡por ejemplo, 21!). Para factores arbitrariamente grandes, necesitaría usar una biblioteca aritmética especializada de precisión arbitraria.