Question

EDIT

Found the answer. It’s a logical error located at

if(carry == 0 && index < 0)
    exit = true;

Since each segment starts with 18 digits (hence the index = 17; right before the while loop), when shift has a value less than that the code will keep writing beyond the answer[0]. I have fixed it by adding an additional condition to trip the exit flag.

Sorry for the confusion.

ORIGINAL QUESTION

Here’s a function I wrote to multiply two integers in the format of char arrays with each cell representing a single decimal number (eg. 1234 would be “1234+”).

char* multichar(char* one, char* two)
{
    // one has m digits, two has n digits
    int m = char_size(one) - 1;
    int n = char_size(two) - 1;
    int m_seg = m / 9 + 1;
    int n_seg = n / 9 + 1;
    int m_head = m % 9;
    int n_head = n % 9;
    int index, shift;
    bool exit = false, m_flag = true, n_flag = true;
    _int64 product, alpha, bravo;
    char carry = 0, sum;
    char temp[18];
    char* answer = new char[m + n + 1];
    memset(answer, 0, m + n + 1);
    if(m_head == 0)
    {
        m_seg--;
        m_flag = false;
    }
    if(n_head == 0)
    {
        n_seg--;
        n_flag = false;
    }

    for(int i = n_seg - 1; i > -1; i--)
    {
        for(int j = m_seg - 1; j > -1; j--)
        {
            shift = m + n - (m_seg + n_seg - i - j) * 9 + 17;
            if(i == 0 && n_head != 0)
                bravo = segtoint(two, 0, n_head);
            else
                bravo = segtoint(two, n_head + (i - n_flag) * 9, 9);
            if(j == 0 && m_head != 0)
                alpha = segtoint(one, 0, m_head);
            else
                alpha = segtoint(one, m_head + (j - m_flag) * 9, 9);

            product = alpha * bravo;
            if(product == 0)
                memset(temp, 0, 18);
            else
            {
                for(int k = 17; k > -1; k--)
                {
                    temp[k] = product % 10;
                    product /= 10;
                }
            }
            // add temp to answer from index backwards;
            index = 17;
            exit = false;
            while(!exit)
            {
                if(index < 0)
                    sum = answer[shift] + carry;
                else
                    sum = answer[shift] + temp[index] + carry;
                carry = sum / 10;
                answer[shift] = sum % 10;
                index--;
                shift--;
                if(carry == 0 && index < 0)
                    exit = true;
            }
        }
    }
    answer[m + n] = one[m] == two[n]? '+':'-';

    return answer;
}

In my int main() I put

char* omega = multichar(delta, echo);
delete[] omega;
return 0;

But that results in a BLOCK IS VALID error… Why can’t I delete the pointer?

Answer 1

Your size calculations are off. For example, for char_size(one) == 1 and char_size(one) == 1 you get m = n = 0 and m_seg = n_seg = 1. Then in the first iteration of the loops you have i = 0 and j = 0 and from that:

shift = 0 + 0 - (1 + 1 - 0 - 0) * 9 + 17;

That is shift = -1. Later in that loop you write to answer[shift], which will be out of bounds of the array.