C factorial program using recursion - c

Question

The program takes an input, and should calculate the factorial of the number. However, after the number has been inputted there is a delay and the program stops
so far I haven't changed the code much from my initial attempt as I do not fully understand recursion and sunbroutines in C.
int calcFactorial(int n);
int input = 0, answer = 0;
int main()
{
int n = 0;
printf("Enter number:\n");
scanf("%d", &input);
answer = calcFactorial(input);
printf("The factorial of %d is %d.\n", input, answer);
system("pause");
return 0;
}
int calcFactorial(int n){
int factorial = 0;
if (n==0){
factorial = 1;
}
else{
factorial = n * calcFactorial(n-1);
printf(factorial);
}
return factorial;
}

Answer 1

This statement in the function calcFactorial
printf(factorial);
has undefined behaviour because the first parameter of the function printf is declared as const char * while you are supplying an object of the type int.
Remove the statement from the function.
Or if you want to get intermediate values then write
printf( "%d\n", factorial);
Also take into account that for the type int that usually has size of 4 bytes the maximum number for which you can get a valid value of the factorial is equal to 12.
You could use type unsigned long long int instead of the type int. In this case you can calculate the factorial for a number equal to 20.
Here is a demonstrative program
#include <stdio.h>
unsigned long long int calcFactorial( unsigned long long int n )
{
return n == 0 ? 1 : n * calcFactorial( n - 1 );
}
int main( void )
{
unsigned long long int input = 0, answer = 0;
printf( "Enter number: " );
scanf( "%llu", &input);
answer = calcFactorial( input );
printf( "The factorial of %llu is %llu.\n", input, answer );
}
Its output might look like
Enter number: 20
The factorial of 20 is 2432902008176640000.
The return statement in the function can be rewritten also the following way
unsigned long long int calcFactorial( unsigned long long int n )
{
return n < 2 ? 1 : n * calcFactorial( n - 1 );
}

Answer 2

However, after the number has been inputted there is a delay and the
program stops
As has already been pointed out by others, printf(factorial) has undefined behavior. It should be removed or it should be called properly (e.g. printf("%d\n", factorial)).
Not sure why you have system("pause") in there as it seems unnecessary.
Removing those two items from your code, I had no trouble running it and getting the correct answer for a factorial up to 12. Again, as has been pointed out by others, your function will only be valid up to 12! due to integer overflow.
Other than that, your code could be formatted better for the input, for example:
/* formats better than original */
printf("Enter number: ");
scanf("%d", &input);
printf("\n");
You can slim down your calcFactorial function as there is no need for the int factorial variable or the else clause. So you could make it look like this:
int calcFactorial(int n){
if (n == 0) return 1; //base case, 0! is 1
return n * calcFactorial(n - 1); //all other cases
}
I do not fully understand recursion and sunbroutines in C
Essentially, your function will be called over and over with n, and each time it is called we refer to that as an instantiation, and in each instantiation n is one less than it was in the previous instantiation. This will happen until the base case is reached (n == 0) then that instance will return to the instance before it, and this will happen until all instances have returned.
For simplicity sake, let's walk through calcFactorial(3). The base case is reached which is the instance that terminates further recursive calls and returns 1. In the instance before the base case was reached, n == 1 so that instance will return 1*1 since the instance before it returned 1. The instance before that was n == 2 so that instance returns 2*1. The instance before that was the first instance n == 3, so that instance returns 3*2. All instances have now returned and the result is 6 and that's what we expect for 3!.
You can learn more about recursion here