C plus plus program to find factorial of given number using function overloading?

Answer 1

Use this function: long factorial(int N)

{

if (N == 0)

{

return 1;

}

else

{

return N*factorial(N-1);

}

}

Answer 2

Factorial in C++ is the same as factorial in mathematics. For a given integer, N, the factorial, denoted N!, is the product of all integers in the closed range 1 to N, where 0! is 1. The problem with factorials is that the largest factorial you can store in a 64-bit integer is 20!. To cater for larger factorials you need a numeric library capable of handling larger integers, such as the GMP library.

Answer 3

The factorial of a given number in C++ is the same as the factorial for a given number in mathematics. That is, the language is immaterial -- the algorithm remains the same.

The factorial of positive integer n is denoted n! and is the product of all positive integers less than or equal to n.

Thus the factorial of 5 is 5!, which 5 x 4 x 3 x 2 x 1 = 120.

Although the factorial of a given number is a recursive operation (and is often used to demonstrate recursive functions), an iterative approach uses less memory.

The basic algorithm is to successively multiply a variable initialised to 1 by all the integers from 2 to n. In C++ this can be implemented as follows:

int factorial(const int number)

{

int product = 1;

int multiplier = 1;

while (multiplier++<number)

product*=multiplier;

return product;

}

While the implementation is fairly simple, the main problem to overcome is that 12! is the largest factorial that will fit into a 32-bit integer. Even if we rewrite the function to work with 64-bit integers we're still limited to factorials up to 20!. Floating-point values give a bit more scope, but even 64-bit IEEE 754 floating-point can only cater for 170!. When you consider that the humble scientific calculator provided with Windows 7 and 8 can cater for factorials up to 3248!, we've clearly got a long way to go.

To cater for large factorials (and large numbers in general), you must first implement a large integer type that is capable of expanding to cater for overflows. In other words, the type should encapsulate a dynamic array and should (at the very least) implement the post-fix increment, compound multiply and less than operators. Thus if your type is called big_int, you can implement your factorial function as follows:

big_int factorial(const big_int number)

{

big_int product = 1;

big_int multiplier = product;

while (multiplier++<number) product*=multiplier;return product;

}

Your big_int type should ideally support all standard numeric operations as well conversion to and from integer strings for input/output purposes.