Having trouble with dynamic memory. Any help would be greatly appreciated. Thanks!

[johndoejohndoe]

I've begun constructing a class that overrides the default limitation of the size of an integer by employing dynamic memory and arrays. SPECIFICALLY MY OVERLOADED ADD OPERATOR METHOD IS NOT FUNCTIONING PROPERLY. It works when the two HugeInteger objects are equally sized; otherwise, it fails. Nonetheless, I am not receiving segmentation faults. thanks for any help!!!

Here is my cpp file (the driver file simply adds two objects of HugeInteger)

#include "integer.h"

        //////////////////
        //global methods//
        //////////////////

        //
        //overloaded istream operator
        istream &operator>>(istream &in, HugeInteger &x){

                x.input(in);

                return in;


        }

        //
        //overloaded ostream operator
        ostream &operator<<(ostream &out, HugeInteger &x){

                x.display(out);

                return out;

        }

        /////////////////
        //class methods//
        /////////////////

        //
        //default constructor

        HugeInteger::HugeInteger(){
                number = NULL;
                sigDigits = 0;
        }

        //
        //accessor method to return static member MAXDIGITS
        int HugeInteger::getMAXDIGITS(){

                return MAXDIGITS;

        }

        //
        //overloaded addition operator method to add two strings of numbers
        HugeInteger HugeInteger::operator+(const HugeInteger &x){

                HugeInteger sum;

                if(x.sigDigits>=sigDigits){
                        sum.sigDigits = x.sigDigits+1;
                }else{
                        sum.sigDigits = sigDigits+1;
                }

                sum.number = new int[sum.sigDigits];

                for (int z=0;z<sum.sigDigits;z++){
                        sum.number[z]=0;
                }

                for(int i=sigDigits-1,j=x.sigDigits-1,k=sum.sigDigits-1;i>=-1,j>=-1,k>=0;i--,j--,k--){

                        if(j!=-1&&i!=-1){
                                sum.number[k]=number[i]+x.number[j];
                        }else if(j==-1&&i!=-1){
                                sum.number[k]=number[i];
                        }else if(i==-1&&j!=-1){
                                sum.number[k]=x.number[j];
                        }else{
                                break;
                        }

                        if(sum.number[k]>=10){
                                sum.number[k]-=10;
                                sum.number[k+1]+=1;
                        }
                }
                return sum;
        }

        //
        //overloaded multiplication operator method to multiply two strings of numbers
        HugeInteger HugeInteger::operator*(const HugeInteger &x){

                /*
                HugeInteger product;
                return product;
                */
        }

        //
        //overloaded equality method that returns a boolean value accordingly
        bool HugeInteger::operator==(const HugeInteger &x){
                bool isEqual = false;

                if(sigDigits == x.sigDigits){
                        for(int i=MAXDIGITS; i>MAXDIGITS-sigDigits;i--){
                                if(number[i] != x.number[i]){
                                        break;
                                }else{
                                        isEqual = true;
                                }
                        }
                }

                return isEqual;
        }

        //
        //overloaded anti-equality method that returns a boolean value accordingly
        bool HugeInteger::operator!=(const HugeInteger &x){
                bool isnotEqual=true;

                if(*this==x){
                        isnotEqual = false;
                }

                return isnotEqual;
        }

        //
        //overloaded greater than method that returns an appropriate boolean value
        bool HugeInteger::operator>(const HugeInteger &x){
                bool isGreater = false;

                if(sigDigits>x.sigDigits){
                        isGreater=true;
                }else if(sigDigits == x.sigDigits){
                        for(int i=MAXDIGITS-sigDigits;i<MAXDIGITS;i++){
                                if(number[i] > x.number[i]){
                                        isGreater = true;
                                        break;
                                }
                        }
                }else{
                        isGreater=false;
                }
                return isGreater;
        }

        //
        //overloaded greater than or equal to method that returns an appropriate boolean value
        bool HugeInteger::operator>=(const HugeInteger &x){
                bool isGTorEQ=false;

                if((*this == x) || (*this>x)){
                        isGTorEQ = true;
                }
                return isGTorEQ;
        }

        //
        //overloaded less than method that returns a boolean value accordingly
        bool HugeInteger::operator<(const HugeInteger &x){

                return ( !(*this > x) );
        }

        //
        //overloaded less than or equal to operator that returns a relevant boolean value
        bool HugeInteger::operator<=(const HugeInteger &x){

                 bool isLTorEQ=false;

                if((*this == x) || (*this<x)){
                        isLTorEQ = true;
                }

                return isLTorEQ;
        }

        //
        //overloaded equality operator method
        HugeInteger HugeInteger::operator=(const HugeInteger &x){

                if(number == NULL){
                        number = new int[x.sigDigits];
                }else{
                        delete [] number;
                        number = new int[x.sigDigits];
                }

                sigDigits = x.sigDigits;

                for(int i=x.sigDigits;i>=0;i--){
                        number[i] = x.number[i];
                }

                return *this;
        }

        //
        //method to check if a given number is zero
        bool HugeInteger::isZero(const HugeInteger &x){
                bool isZero = false;

                if (sigDigits != 0){
                        for(int i=MAXDIGITS;i>MAXDIGITS-sigDigits;i--){
                                if(x.number[i]!=0){
                                        isZero = false;
                                }
                        }
                }
                return isZero;
        }

        //
        //input method
        void HugeInteger::input(istream &in){

                string temp;
                in >> temp;
                sigDigits = 0;
                number = new int[temp.length()];

                for(int i = temp.length()-1;i>=0;i--){
                        char x = temp[i];
                        number[i] = atoi(&x);
                        sigDigits++;
                }
        }

        //
        //display method
        void HugeInteger::display(ostream &out){

                for(int i=0;i<sigDigits;i++){

                        out << number[i];
                }
        }

[SakurasouBusters]

.

[cire]

There are a few issues with your code.
for(int i=sigDigits-1,j=x.sigDigits-1,k=sum.sigDigits-1;i>=-1,j>=-1,k>=0;i--,j--,k--){

The condition: i>= -1, j >= -1, k>=0 is equivalent to: k >= 0.

operator+ can be implemented in terms of operator+= as a non-member function.

operator= should not return a copy.

The way you use atoi in HugeInteger::input is wrong.

I don't see a copy constructor or destructor, both of which should be implemented for your type.

SakurasouBusters wrote:

Send me a private message.

I would suggest not sending a private message to the local troll.

[boost lexical cast]

@cire

I did not know SakarusouBusters was a troll. It seems obvious now.

Always seemed to criticize my responses and only gave me a reply saying that my code doesn't compile. Not helpful.

I'll keep this in mind.

[SakurasouBusters]

@boost lexical cast
How about you?
If your code does not even compile, how can it possibly help other people?

[boost lexical cast]

@SakurasouBusters

Every time I fixed my code and those times where my code didn't compile were 1 - 2 times...

I actually helped while you spammed "send me private message" and didn't help at all. I'm not arguing anymore.