Решил посчитать (2n)!

#include <iostream>
using namespace std;
unsigned long factorial (unsigned long n)
{
 if (n==1 || n==2) return n;
  else return n*factorial(n-1);
}
int main()
{
 cout<<"Input n: ";
 int n;
 cin>>n;
 cout<<"(2*n)! = "<<factorial(2*n)<<endl;
 system("pause");
 return 0;
}

double factorial(int num){
        double fact = 1;
        for(int i = 1; i <= num; i++){
                fact *= i; 
        }
        return fact;
}

double d_fact (double num, double lim = 20){
        double summ;
        for(int n = 0; n < limn; n++){
                summ= factorial(2*n);
        }
        return summ;
}

#include <iostream>
#include <vector>
#include <cmath>
#include <sstream>
#include <string>
#include <iomanip>
#include <cstdlib>
 
class BigInteger
{
protected:
 
    std::vector<int> value;
    static const int base = 1e9;
    static const int count_of_digits = 9;
   
public:
 
    BigInteger();  
    BigInteger( const std::string& );
    BigInteger( long long );
   
    BigInteger& operator = ( const BigInteger& );
    BigInteger& operator += ( const BigInteger& );
    BigInteger& operator *= ( const BigInteger& );
   
    friend BigInteger operator + ( const BigInteger&, const BigInteger& );
    friend BigInteger operator * ( const BigInteger&, const BigInteger& );
   
    friend std::istream& operator >> ( std::istream&, BigInteger& );
    friend std::ostream& operator << ( std::ostream&, const BigInteger& );
};
 
int main()
{   
    int n;
    std::cin >> n;
 
    BigInteger res(1);
    
    for (int i = 2; i <= 2 * n; ++i)
        res *= i;
        
    std::cout << res;
}
 
BigInteger::BigInteger( const std::string& str )
{
    for (int i = str.length() ; i > 0 ; i -= count_of_digits)
    {
        if ( i < count_of_digits )
        {
            value.push_back( atoi( str.substr(0, i).c_str() ) );
        }
        else
        {
            value.push_back( atoi( str.substr(i - count_of_digits, count_of_digits).c_str() ) );
        }
    }
}
 
BigInteger::BigInteger()
{
    value.push_back(0);
}
 
BigInteger::BigInteger( long long x )
{
    std::ostringstream ost;
    ost << x;
    std::string str = ost.str();
   
    for (int i = str.length() ; i > 0 ; i -= count_of_digits)
    {
        if ( i < count_of_digits )
        {
            value.push_back( atoi( str.substr(0, i).c_str() ) );
        }
        else
        {
            value.push_back( atoi( str.substr(i - count_of_digits, count_of_digits).c_str() ) );
        }
    }
   
}
 
BigInteger& BigInteger::operator += ( const BigInteger& b )
{
    for ( int temp = 0, i = 0; i < (int) std::max( this->value.size(), b.value.size() ) || temp != 0 ; ++i)
    {
        if ( i == (int) value.size() )
            value.push_back( 0 );
       
        value[i] += temp + ( i < (int) b.value.size() ? b.value[i] : 0 );
        temp = value[i] >= base;
       
        if ( temp != 0 )
            value[i] -= base;
    }
   
    return *this;
}
 
BigInteger operator + ( const BigInteger& a, const BigInteger& b )
{
    BigInteger c = a;
    c += b;
    return c;
}
 
std::istream& operator >> ( std::istream& stream, BigInteger& big )
{
    std::string str;
    std::cin >> str;
    big = BigInteger(str);
   
    return stream; 
}
 
std::ostream& operator << ( std::ostream& stream, const BigInteger& big )
{
    if ( big.value.empty() )
        stream << 0;
    else
        stream << big.value.back();
       
    for (int i = (int) big.value.size() - 2; i >= 0; --i)
    {
        stream << std::setfill('0') << std::setw(BigInteger::count_of_digits) << big.value[i];
    }
   
    return stream;
}
 
BigInteger& BigInteger::operator = ( const BigInteger& big )
{
    this->value = big.value;
   
    return *this;
}
 
BigInteger operator * ( const BigInteger& a, const BigInteger& b )
{
    BigInteger c;
    c.value.resize( a.value.size() + b.value.size() );
   
    for (int i = 0; i < (int) a.value.size(); ++i)
    {
        for (int j = 0, carry = 0 ; j < (int) b.value.size() || carry != 0 ; ++j)
        {
            long long cur = c.value[i + j] + a.value[i] * 1ll * ( j < (int) b.value.size() ? b.value[j] : 0 ) + carry;
           
            c.value[i + j] = int( cur % BigInteger::base );
           
            carry = int ( cur / BigInteger::base );        
        }  
    }
   
    while ( c.value.size() > 1 && c.value.back() == 0 )
    {
        c.value.pop_back();
    }
   
    return c;
}
 
BigInteger& BigInteger::operator *= ( const BigInteger& big )
{
    BigInteger a (*this);
    *this = a * big;
    return *this;
}