I am writing a class for large numbers up to 2 ^ 512. I’m using the unsigned __int64 array. The addition of numbers is inadequate, due to the variable c. The algorithm was taken from the book. Can you suggest a working algorithm?

class BigInt {
public:
  unsigned __int64 number [8];
  BigInt ()
  {
    for (int i = 0; i & lt; 8; i ++)
    {
      number [i] = 0;
    }
  }
  const BigInt operator + (const BigInt & amp; rv) const
  {
    BigInt res;
    unsigned __int64 c = 0, t = 0;
    for (int i = 0; i & lt; 8; i ++)
    {
      t = number [i] + rv.number [i] + c;
      c = t% LLONG_MAX;
      res.number [i] = c;
    }
    res.number [7] = t;
    return res;
  }
};

Answer 1, authority 100%

There is absolutely no need to use the % and / operations. This is shooting sparrows with a cannon, not to mention the fact that such calculations must be performed in a type wider than your unsigned __int64 . And you don’t have this type at your disposal.

There is also no need to bind to a specific type through constants like LLONG_MAX (and why is the signed maximum suddenly used?).

Remember that c can only be 0 or 1 .

This is how it might look

BigInt operator + (const BigInt & amp; rv) const
{
  BigInt res;
  unsigned __int64 carry = 0;
  for (int i = 0; i & lt; 8; i ++)
  {
    res.number [i] = number [i] + rv.number [i] + carry;
    carry = carry? res.number [i] & lt; = number [i]: res.number [i] & lt; number [i];
  }
  return res;
}

Answer 2, authority 50%

There is at least one blunder in your code: instead of

c = t% LLONG_MAX;
res.number [i] = c;

needed

c = t / LLONG_MAX;
res.number [i] = t% LLONG_MAX;

Accordingly, the final res.number [7] = t; is not needed.

In addition, the type t must be wider than the type of number elements.