Multipling Integers in Arrays

I am having a problem trying to multiply arrays. Everything works fine until the second(bottom) number is more then 6 digits. Any help would be great.
Here is what I have:

Code:

---

CHugeInt CHugeInt::operator*(const CHugeInt &n)
{
        CHugeInt cTemp, cWork;
        int nCarry = 0;

        for (int y = 29; y >= 0; y--)
        {
                for (int i = 0; i <= 29; i++)
                {
                        cWork.m_nInt[i] = 0;
                }

                for (int x = 29, a = y; x >= 0; x--, a--)
                {
                        cWork.m_nInt[a] = ((m_nInt[x] * n.m_nInt[y]) % 10) + nCarry;
                        nCarry = (m_nInt[x] * n.m_nInt[y]) / 10;
                }       

                cTemp = cTemp + cWork;
        }

        return (cTemp);
}

---

My guess would be that your array m_nInt stores a value that is to big. Is m_nInt of type int?? It would be easier if you posted more code.

Also the code

Code:

---

nCarry = (m_nInt[x] * n.m_nInt[y]) / 10;

---

If m_nInt[x] and n.m_nInt[y]) stores large values nCarry wouldn´t hold such big numbers.

the variable m_nInt[x] only holds numbers between 0-9.
ex:

the number 12345 is stored like this.

m_nInt[29] = 5
m_nInt[28] = 4
m_nInt[27] = 3
m_nInt[26] = 2
m_nInt[25] = 1
m_nInt[24] = 0
...
...
...
...
m_nInt[0] = 0

Hmm, this is tricky. I have double-checked it many times and it should work. You say that when the second number is more than 6 digits something goes wrong. What number are you using in that function(some example just). Can it be that the number is larger than 10^29??? And are you absolutly sure that the overloading of + is correct implemented??

Maybe should you also "reset" the cTemp-array in the beginning

Code:

---

for (int k = 0; k <= 29; k++)
                {
                        cTemp.m_nInt[k] = 0;
                }

---

I have a for loop their for cWork. cTemp is set to 0's when it is declared, default constructor sets these to 0. When adding large numbers, ex. 999999999999999999 + 7654321 it displays the correct answer. So I am pretty sure the + operator is working correctly. The example that isn't working is:
7654321 * 78912345

m_nInt[29] = 1 n.m_nInt[29] = 5
m_nInt[28] = 2 n.m_nInt[28] = 4
m_nInt[27] = 3 n.m_nInt[27] = 3
m_nInt[26] = 4 n.m_nInt[26] = 2
m_nInt[25] = 4 n.m_nInt[25] = 1
m_nInt[24] = 5 n.m_nInt[24] = 9
m_nInt[23] = 6 n.m_nInt[29] = 8
m_nInt[22] = 7 n.m_nInt[29] = 7

I added my own test examples and determined that after the bottom number hits the n.m_nInt[24] spot it doesn't work correctly.

Quote:

---

cTemp is set to 0's when it is declared, default constructor sets these to 0

---

In other words you "resets" cTemp only once. Is it possible that cTemp is used before you invoke operator*. In that case there might be garbage values which can give unexpected results.

Ahhh got it :D. Check in this code-snippet

Code:

---

HugeInt HugeInt::operator *(const HugeInt &ref)
{
        HugeInt Result; //Constructor should set all elements in array to 0
        for (int y = 29; y >= 0; y--)
        {
                HugeInt tempResult;
                int nCarry=0;
                for (int x = 29,a = y; x >= 0; x--,a--)
                {
                        tempResult.number[a] = ((number[x] * ref.number[y]) % 10) + nCarry;
                        nCarry = ((number[x] * ref.number[y]) / 10);
                }

                Result = Result + tempResult;
        }
        return Result;
}

---

I´ve made my own version of yours CHugeInt. I´ve notised one that you don´t reset yours nCarry after a "whole" multiplication and every time you have garbage values for cCarray it results that you "sometimes" get strange results. Be sure that you have overloaded the operators right (operator + and =)

I´ve have testet it and it should work.

Thank you very much, it works better but there is still a little problem.
Example: The first is from the program, the second is from a calculator.

123456789 * 123456789 = 15241578550090521

123456789 * 123456789 = 15241578750190521

So everything is working good, but somewhere there is a problem with the math.
Here is my addition code:

Code:

---

CHugeInt CHugeInt::operator+(const CHugeInt &n)
{
        CHugeInt cTemp;
        int nCarry = 0;

        for (int x = 29; x >= 0; x--)
        {
                cTemp.m_nInt[x] = m_nInt[x] + n.m_nInt[x] + nCarry;

                if (cTemp.m_nInt[x] > 9)
                {
                        cTemp.m_nInt[x] %= 10;
                        nCarry = 1;
                }
                else
                {
                        nCarry = 0;
                }
        }

        return (cTemp);
}

---

Here is a easier version

Code:

---

HugeInt HugeInt::operator +(const HugeInt &n)
{
                int nCarry=0;
                HugeInt cTemp;
                for (int i = 29; i >=0; i--)
                {
                        cTemp.m_nInt[i] = ((m_nInt[i] + n.m_nInt[i]) % 10) + nCarry;
                        nCarry = (m_nInt[i] + n.m_nInt[i]) / 10;
                }
                return cTemp;
}

---

Hopefully it works :)

Thank you very much, everything works now. I'll post again when division doesn't work ;)