在数组C ++中乘以大字符串

Question

Here I've got a SafeArray(not that safe but my teacher said it's fine) class and a bigint class. My bigint class can add and subtract just fine but when I try the multiply function it doesn't print anything at all, i've tried debugging and stepping through it but I can't seem to figure it out, been working on it for a while and am hopelessly stuck. Any help would be appreciated. Thanks

        #include <iostream>
        using namespace std;
#include <algorithm>

template<typename Element>
class SafeArray
{
    int size;
    Element*Array;
    Element def;

public:
    SafeArray()                         //default constructor(with no parameter)
    {
        size = 10;
        Array = new Element[size]();
    }

    SafeArray(int value)         //constructor with one int
    {
        size = value;
        Array = new Element[value];
        for (int i = 0; i < size; ++i)
            Array[i] = 0;
    }

    ~SafeArray() {
        delete[] Array;
    }                                       //destructor

    SafeArray(const SafeArray& rhs) : size(rhs.size), Array(new Element[size]), def(rhs.def)
    {
        for (int i = 0; i < size; ++i )
            Array[i] = rhs.Array[i];
    }

    SafeArray& operator=(SafeArray rhs)
    {
        std::swap(Array, rhs.Array);
        std::swap(size, rhs.size);
        std::swap(def, rhs.def);
        return *this;
    }

    Element get(int pos)    const                 //get method
    {
        if (pos<0)
        {
            cout << "error";
        }

        return Array[pos];
    }

    void set(int pos, Element val)
    {
        if (pos<0)
        {
            cout << "error";
            return;
        }
        if (pos >= size)
        {
            resize(pos + 1);
        }
        Array[pos] = val;
    }

    void resize(int new_size)
    {
        Element*temp = new Element[new_size];
        for (int i = 0; i<size; i++)
        {
            temp[i] = Array[i];
        }
        delete[]Array;
        Array = temp;
        size = new_size;
    }

    void set_default(Element d)        //set_default
    {
        def = d;
    }

    int get_size()                       //get size
    {
        return size;
    }
};

int size = 100; //for testing

class bigint
{
    SafeArray<int> *arr;
public:
    bool sign;
bigint()                                                   //initializes to zero
    {
        arr = new SafeArray<int>;
        for(int i =0;i < size; i++)
            arr->set(i,0);
    }

void print()                                               //prints numbers without zeroes in front
    {
        bool start_num=false;
        for(int i = 0;i <arr->get_size() ;i++)
        {
            if(arr->get(i)!=0 && start_num==false )
            {start_num=true;
                cout << arr->get(i);}
         else if(start_num==true)
             cout<<arr->get(i);

        }

       cout<<endl;
    }
    void assign(const bigint &A)                             //
{
    for(int i=0;i<arr->get_size();i++)
    {                                                            //Ways to initialize stuff
        arr->set(i,A.arr->get(i));
    }

}
void assign(string num)                                  
    {
        long len = num.length();
        int j=arr->get_size()-1;
        for(long i=len-1;i>=0;i--)
        {
            arr->set(j,num[i]-48);
            j--;
        }
    }
void add_pos(const bigint &A)                                //add big ints
    {
        int carry=0;
        for(int i=size-1;i>=0;i--)
           {
               int result = arr->get(i)+A.arr->get(i)+carry;
               arr->set(i,result%10);
               carry=result/10;
           }
    }

void sub_pos(const bigint &A)
        {
           int borrow=0;
           for(int i=size-1;i>=0;i--)
           {
              int result = ((arr->get(i) - A.arr->get(i)-borrow));
              if(result<0)
              {
                 arr->set(i,result +10);
                 borrow = 1;
              }
              else
              {
                 arr->set(i,result);
                 borrow = 0;
              }
            }
        }


    void multiply(const bigint &A)
        {
            for(int i=size-1;i>=0;i--)
                {
                  int carry=0;

               for(int j=size-1;j>=0;j--)
                 {
                   int product=((arr->get(i)*A.arr->get(j))+carry);
                   arr->set(i+j,product%10);
                   carry=product/10;
                 }
            }
    }

    }

int main()
{
 bigint a,b;
a.assign("1234");
b.assign("5678");
a.multiply(b);
a.print();

return 0;
}

Answer 1

Given the comments and the following changes to SafeArray

http://coliru.stacked-crooked.com/a/0f22a24e04421ae1

one way to achieve multiplication is to leverage the functions you say already work, namely bigint::add_pos and bigint::sub_pos to do the multiplication. The goal is to simulate m * n by adding m to itself n-1 times. For example, 4 * 3 is the same as 4 + 4 + 4 (we added 4 to itself 2 times).

Note: If the requirements are that you have to write the multiply code totally independent of the existing functions, and/or use the unsafe version of SafeArray , then this answer won't help you and you will have to do things from scratch.

---

Preliminaries:

The first thing that should be done is to replace the pointer to the SafeArray in your bigint class to an actual instance:

SafeArray<int> arr;

The second changes will be the changing of arr-> to arr. within your bigint class. This should be seamless change.

Now, the third thing to do is to create a helper function in bigint , call it is_zero to determine if the bigint represents 0. You can easily do this by writing a loop and making sure that all entries in arr are 0 . The function should be const , ie

bool is_zero() const;

The last change is that you have a bug in your bigint default constructor. That bug is that you didn't initialize the arr SafeArray to have size elements. You used the default, which is only 10. To fix this, initialize the arr to size elements

bigint() : arr(size)
{
    for (int i = 0; i < size; i++)
        arr.set(i, 0);
}

I kept your global variable size , but it really should be removed from being a global, and your bigint class should use arr.get_size() to get the size of the array.

---

Implementation:

So now we get to the implementation of multiply using your existing functions. It is kind of a roundabout way, and it may be slow for very large values.

Let's get to the code:

void multiply(const bigint &A)
{
    // check for multiplication by 0
    if ( A.is_zero() )
    {
       *this = A;  // copy our paramter (which is 0) to this object
       return;  
    }

    bigint tempInt(*this);  // our original value
    bigint startVal(*this);  // our running total
    bigint startA(A);   // our counter
    bigint subtractor;
    subtractor.assign("1");  // our decrementor for looping

    // subtract one from the number of times we need to add
    startA.sub_pos(subtractor);

    // keep adding until the number of times we've added is 
    // sufficient
    while (!startA.is_zero()) 
    {
        // add to running total
        startVal.add_pos(tempInt);

        // subtract 1 from our counter
        startA.sub_pos(subtractor);
    } 

    // assign the final result to our object, and we're done
    *this = startVal;
}

So what did we do?

First we checked for multiplication of 0. If so, then we zero out everything and just return.

If not a multiplication of 0, we set up a temporary bigint that holds our original value (tempInt). Then we setup another bigint that holds our current "running total" ( startVal ). We set up another bigint that will hold our multiplier startA . Note how we use the copy constructor to construct temporary bigint 's from existing ones. This would not be possible if your SafeArray wasn't made truly safe (ie you stuck with your original implementation instead).

Now, the trouble happens when we need to keep a count of the number of times we add. To do that, a fourth bigint called subtractor was set up, and all it does is initialize itself to 1 . We need this to help us subtract 1 from our bigint multiplier (this is where bigint::sub_pos comes into play in our design).

Note that we had to do all of this to subtract 1, and not use simple int 's. The reason -- if the bigint that is passed to multiply is a huge number that won't fit into an int or long , then we can't use the "traditional" C++ integer types. We are dealing with 100 digit numbers and there is probably no C++ compiler that has native 100 digit integer types.

So we start out by subtracting 1 from our multiplier. If the multiplier is now zero, we just don't loop (essentially this takes care of the multiplication by 1 case, but see the further edit below for an optimized way to accomplish multiplication by 1).

If the multiplier is greater than 0, all we do now is call add_pos on our running total until our multiplier goes to 0. We do that by testing our multiplier to see if it has reached 0 by calling is_zero each time for the while() condition. Each time we call sub_pos to subtract 1 from the multiplier.

Work it out on paper in terms of a high-level look at what this multiply function is doing -- you should get the idea of what is being done (sneakily avoiding having to actually write the multiplication code as you did in your question).

At the end, we assign our running total to this . That's it. All using your existing functions, plus an addition of a simple helper, and making your SafeArray class a little safer.

Edit: An optimization you can make is to check for multiplication by 1. The way you do that is to set up the counter, subtract 1 from it, and check if the counter is 0. If it is 0, then return without doing any further work.