Multiply two int arrays - c++

Question

I have a type BigInt which stores large numbers as an array of digits (0-9) in a char array called privately m_digitArray.
I am overloading arithmetic and relational operators to help in development. However, I could not get the multiplicative operator *= to work for me. The code I posted works for single digit operations in int * BigInt only while I'd prefer it work for any length number and for all int * BigInt, BigInt * int, and especially BigInt * BigInt operations. Like it works for 6 * bigInt (with a value of 6) = 36; but not 11 * bigInt (with a value of 10).
BigInt.cpp
Overloaded operator in question
BigInt BigInt::operator *= (const BigInt &rhs){
int size = m_digitArraySize + rhs.getSize();
int* C = new int[size];
int s = size-1;
for(int j= rhs.getSize() - 1; j >= 0; j--){
int carry = 0;
int shift = s;
for(int i = m_digitArraySize - 1; i >= 0; i--){
int m = getDigit(i) * rhs.getDigit(j);
int sum = m + C[shift] + carry;
int num = sum % 10;
int c = sum/10;
C[shift] = num;
carry = c;
shift--;
}
C[shift]= C[shift] + carry;
s--;
}
reallocateArray(size);
// for(int i = 0; i < size < ++i){
// m_digitArray[i] = '0' + C[i];
// }
// Nothing being returned, printing to debug
for (int i = 0; i < size; ++i)
{
cout << C[i];
}
return *this;
}
// Overload the * operator for BigInt * BigInt operations
BigInt operator * (const BigInt &lhs, const BigInt &rhs){
return BigInt(lhs) *= rhs;
}
// Overload the * operator for BigInt * int operations
BigInt operator * (const BigInt &lhs, int num){
return BigInt(lhs) *= num;
}
// Overload the * operator for int * BigInt operations
BigInt operator * (int num, const BigInt &rhs){
return BigInt(rhs) *= num;
}

Answer 1

You have an error in the logic in that you're coding operator * as something that implements operator *= to do it's work. Your problem is that calling:
x = y * z
shouldn't change the value of "y". That's an unwanted side-effect. But if you define operator* for your BigInt as using *= to get the result, that's exactly what it would do. Also if you do that, then calling
x = z * y
will cause different behaviour to "x = y * z", because now z is changed instead of y, which violates basic commutative laws of mathematics.
Start with operator* and operator=, then construct operator *= by chaining together calls to those.
operator* should create a new BigInt, then multiply the two input BigInts (passed as "const BigInt&"), then return the newly-created BigInt. To optimize this, you look into move constructors. but it's not necessary.
operator= is your copy assignment function, it should be later built to use move semantics, but that's also not critical
Then after that you can use *= to combine the two other functions, by merely writing something simple such as:
BigInt BigInt::operator*=(const BigInt &rhs)
{
(*this) = (*this) * rhs;
return (*this);
}

Answer 2

Well I was able to figure it out after some help. Here's the solution to the problem:
BigInt BigInt::operator *= (const BigInt &rhs){
// Create new BigInt to make changes non-destructively
BigInt numbers;
// A safe capacity size for the new BigInt
int size = m_digitArraySize + rhs.getSize();
// If either number is negative, set self to negative
if(!m_isPositive || !rhs.isPositive())
numbers.initializeArray(size, false);
else
numbers.initializeArray(size, true);
// Go through the multiplier
for(int i = 0; i < rhs.getSize(); ++i){
int carry = 0;
// Go through the multiplicand
for(int j = 0; j < m_digitArraySize; ++j){
// The product of multiplicand and multiplier plus the sum of the previous digits and the carry
int product = (getDigit(j) * rhs.getDigit(i)) + numbers.getDigit(i + j) + carry;
// Reset carry, necessary if the product is just a digit
carry = 0;
// Set carry to the tens digit
carry = product / 10;
// Set product to the units digit
product = product % 10;
// Save to the new BigInt
numbers.setDigit(i +j, product);
}
// Inner loop cuts off near the end, continue the loop if there is a carry
int nextDigit = i + m_digitArraySize;
while(carry!=0){
int new_value = numbers.getDigit(nextDigit) + carry;
carry = 0;
carry = new_value / 10;
new_value = new_value % 10;
numbers.setDigit(nextDigit, new_value);
++nextDigit;
}
}
// Remove excess zeros
numbers.normalizeArray();
*this = numbers;
return *this;
}