Перегрузка оператора *(умножения)

class HugeInt
{
private:
    short integer[30];
 
    friend std::ostream &operator<<(std::ostream &, const HugeInt &);
 
public:
    HugeInt(long = 0); //конструктор преобразования/по умолчанию
    HugeInt(const char *);  //конструктор преобразования
    HugeInt(const HugeInt &);   //constr copy
    ~HugeInt();
 
    HugeInt operator+(const HugeInt &) const; //addition HugeInt + HugeInt
    HugeInt operator+(int) const; //addition HugeInt + int
    // операция сложения;
    // Hugelnt + строка, представляющая большое целое значение
    HugeInt operator+(const char *) const; 
    HugeInt operator*(const HugeInt &);
 
#include "stdafx.h"
#include "HugeInt.h"
 
//constructor
HugeInt::HugeInt(long value)
{
    // инициализировать массив нулем
    for (int i = 0; i <= 29; i++)
    {
        integer[i] = 0;
    }
 
    // поместить в массив цифры аргумента
    for (int j = 29; value != 0 && j >= 0; j--)
    {
        integer[j] = value % 10;
        value /= 10;
    }
}
 
// конструктор преобразования символьной строки,
// представляюще большое целое, в объект Hugelnt
HugeInt::HugeInt(const char *string)
{
    // инициализировать массив нулем
    for (int i = 0; i <= 29; i++)
    {
        integer[i] = 0;
    }
 
    // поместить в массив цифры аргумента
    int length = std::strlen(string);
    int k;
 
 
    for (int j = 30 - length; k = 0, j <= 29; j++, k++)
    {
        if (std::isdigit(string[k]))
        {
            integer[j] = string[k] - '0';
        }
    }
}
 
//constr copy
HugeInt::HugeInt(const HugeInt &_hugeIntCopy)   
{
    // инициализировать массив нулем
    for (int i = 0; i <= 29; i++)
    {
        integer[i] = 0;
    }
 
    for (int i = 0; i <= 29; i++)
    {
        integer[i] = _hugeIntCopy.integer[i];
    }
}
 
//destr
HugeInt::~HugeInt()
{}
 
// операция сложения; Hugelnt + Hugelnt
HugeInt HugeInt::operator+(const HugeInt &op2) const
{
    HugeInt temp;
    int carry = 0;
    for (int i = 29; i >= 0; i--)
    {
        temp.integer[i] = integer[i] + op2.integer[i] + carry;
        if (temp.integer[i] > 9)
        {
            temp.integer[i] %= 10;      // редуцировать к 0-9
            carry = 1;
        }
        else
        {
            carry = 0;
        }
    }
    return temp;
}
 
// операция сложения; HugeInt + int
HugeInt HugeInt::operator+(int op2) const
{
    // преобразовать ор2 в Hugelnt, затем вызвать
    // operator+ для двух объектов Hugelnt
    return *this + HugeInt(op2);
}
 
// Hugelnt + строка, представляющая большое целое значение
HugeInt HugeInt::operator+(const char *op2) const
{
    // преобразовать op2 в Hugelnt, затем вызвать
    // operatoг+ для двух объектов Hugelnt
    return *this + HugeInt(op2);
}
 
??????????
HugeInt HugeInt::operator*(const HugeInt &op2)
{
    HugeInt temp;
    int carry = 0;
    for (int i = 29; i >= 0; i--)
    {
        temp.integer[i] = integer[i] * op2.integer[i] + carry;
        if (temp.integer[i] > 9)
        {           
            temp.integer[i] %= 10;      // редуцировать к 0-9
        }
        else
        {
            carry = 0;
        }
    }
    return temp;
}
 
//overload <<
std::ostream & operator<<(std::ostream &output, const HugeInt &num)
{
    int i;
    for ( i = 0; (num.integer[i] == 0) && (i <= 29); i++)
    {
        ;
    }
    if (i == 30)
    {
        output << 0;
    }
    else
    {
        for (; i <= 29; i++)
            output << num.integer[i];
    }
    return output;
}