Factorial implementation of large integer classes

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 10000;

struct BigInt
{
	BigInt(int x = 0)
	{
		memset(arr, 0, sizeof(arr));// Initialize all to 0
		for (len = 1; x; len++)
		{
			arr[len] = x % 10;// Yes x Reverse order preservation 
			x /= 10;
		}
		len--;
	}

	int& operator[](int i)
	{
		return arr[i];// use x[i] Instead of x.arr[i]
	}

	void flatten(int L)// Handle bits that are not single digits into single digits , So it is called flattening ,L Not less than the effective length 
	{
		len = L;
		for (int i = 1; i <= len; ++i)
		{
			arr[i + 1] += arr[i] / 10;
			arr[i] %= 10;
		}
		while (!arr[len])// Eliminate pre 0
		{
			len--;
		}
	}

	void print()// Reverse output 
	{
		for (int i = max(1, len); i >= 1; --i)
		{
			cout << arr[i];
		}
		cout << endl;
	}

	int len;
	int arr[maxn];
};

BigInt operator+(BigInt &a,BigInt &b)
{
	BigInt c;
	int len = max(a.len, b.len);
	for (int i = 1; i <= len; ++i)
	{
		c[i] += a[i] + b[i];
	}
	c.flatten(len + 1);// The maximum length shall not exceed len+1
	return c;
}

BigInt operator*(BigInt& a, BigInt& b)
{
	BigInt c;
	int len = a.len + b.len;
	for (int i = 1; i <= a.len; ++i)
	{
		for (int j = 1; j <= b.len; ++j)
		{
			c[i + j - 1] += a[i] * b[j];//a[i] * b[j] The result of is produced in i+j-1 On a 
		}
	}
	c.flatten(len );// The maximum length shall not exceed len+1
	return c;
}

BigInt operator*(BigInt& a, int& b)
{
	BigInt c;
	int len = a.len;
	for (int i = 1; i <= len; ++i)
	{
		c[i] += a[i] *b;
	}
	c.flatten(len + 11);//int Type longest 10 position , So you can flatten it like this 
	return c;
}

int main()
{
	int n;
	cin >> n;
	BigInt fac(1);
	BigInt ans(0);
	for (int i = 1; i <= n; ++i)
	{
		fac = fac * i;
		ans = ans + fac;
	}
	ans.print();

	return 0;
}