HI, im working on this code which is going to be tested with only positive numbers. I am having trouble with the overloaded + and *, it gives my an error and closes the program down. Is there anything wrong with them or something else has to be fixed???
thanks in advance.
bigInt.h
Code:
//class bigInt implements big integers by storing the digits of a big
//integer in a private vector data member called digit. Since it uses a
//vector the size of the big integer can be indefinitely large. This class
//implements input/output of bigInts, addition/multiplication/pre-increment
//of bigInts, assignment of a bigInt or long int to a bigInt and ==/<
//comparison of bigInts. The operators addition/multiplication/pre-increment/<
//only work for big integers >= 0. By adding additional code they could be
//made to work for negative big integers also.
#ifndef _bigInt_h
#define _bigInt_h
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class bigInt
{
public:
bigInt(); //default constructor, defined
bigInt(long int k); //construct bigInt with value like k, defined
bigInt(const string& s); //construct bigInt with value like string s ,defined
void print(ostream& os) const; //function to output a bigInt, defined
void read(istream& is); //function to input a bigInt, defined
bigInt operator+(const bigInt& bi2) const; //overloads + operator
bigInt operator*(const bigInt& bi2) const; //overloads * operator
bigInt& operator++(); //overloads pre-increment op, defined
const bigInt& operator=(const bigInt& bi2); //copy assignment operator, defined
const bigInt& operator=(long int i); //converts i to bigInt and assigns
//overload comparison operators
bool operator==(const bigInt& bi2) const; //defined
bool operator<(const bigInt& bi2) const;//defined
private:
char sign; //stores the sign '+' or '-'. Not really
//needed in this program because you only have
//to handle positive numbers (numbers >= 0), but
//would be needed in a complete program.
vector<int> digit; //vector to store digits of a bigInt with
//one digit in each element of the vector.
//A more efficient version of the program
//would store several digits in each element.
//digit[0] is the 1's digit, digit[1] is the 10's
//digit, digit[2] is the 100's digit, etc.
void convertString(const string& s); //converts string into bigInt
//representaion., defined
};
//overloads << and >> operators as non-member functions using
//public member functions print and read.
ostream& operator<<(ostream& os, const bigInt& bi); //defined
istream& operator>>(istream& is, bigInt& bi);//defined
#endif
bigInt.cpp
Code:
#include <iostream>
#include <string>
#include <cctype>
#include <cstdlib>
#include "bigInt.h"
using namespace std;
bigInt::bigInt()
{
}
bigInt::bigInt(long int i)
/*this function should determine whether i is positive or
negative and set the sign accordingly. It then extracts
the digits from i and stores them in the vector digit.
This can be done by nextdigit = i % 10; i = i / 10; For
example if i is 456 then nextdigit = 456 % 10; sets
nextdigit to 6 and i = i / 10; sets i to 45 so i is ready
to have the next digit extracted.
*/
{
long int nextdigit;
if(i < 0)
{
sign = '-';
i=abs(i);
}
else sign='+';
while(i != 0)
{
nextdigit=i % 10;
digit.push_back(nextdigit);
i=i/10;
}
}
bigInt::bigInt(const string& s)
{ convertString(s);
}
void bigInt::print(ostream& os) const
{ int k;
os<<sign;
for(k = digit.size() - 1; k >= 0; k--) //print right to left
os<<digit[k]; //high order digits first
}
void bigInt::read(istream& is)
{ string s;
is>>s;
convertString(s);
}
bigInt& bigInt::operator++() //++ only works correctly for positive bigInts
{ int i, sum, newdigit, carry;
sum = digit[0] + 1;
newdigit = sum % 10;
carry = sum / 10;
digit[0] = newdigit;
i = 1;
while(i < digit.size() && carry != 0)
{ sum = digit[i] + carry;
newdigit = sum % 10;
carry = sum / 10;
digit[i] = newdigit;
i++;
}
if (carry != 0) digit.push_back(carry);
return *this;
}
void bigInt::convertString(const string& s)
{ int j, k, nextdigit;
if (s[0] == '+' || s[0] == '-')
{ sign = s[0];
k = 1; //process from subscript 1 so sign not considered again
}
else
{ sign = '+'; //no sign in string then positive number
k = 0; //no sign so process from subscript 0
}
digit.resize(0); //resize the vector digit to 0
for(j = s.size() - 1; j >= k; j--) //process digits in string from right
if (isdigit(s[j])) //to left - low order digits first
{ nextdigit = s[j] - '0'; //convert character digit to int
digit.push_back(nextdigit);
}
else
{ cerr<<"Bad string argument for convertString function"<<endl;
cin.get(); cin.get(); //to pause console i/o screen
exit(1);
}
}
ostream& operator <<(ostream& os, const bigInt& bi)
{
bi.print(os);
return os;
}
istream& operator >>(istream& is, bigInt& bi)
{
bi.read(is);
return is;
}
bigInt bigInt::operator *(const bigInt& bi2)const
{
int mul;
int carry=0;
int k;
int len=this->digit.size();
bigInt tem;
if(len < bi2.digit.size())len=bi2.digit.size();
for(k=0;k<len;k++)
{
mul=this->(digit[k]*bi2.digit[k])+carry;
carry=sum/10;
mul=mul%10;
tem.digit.push_back(mul);
}
if(carry != 0)tem.digit.push_back(carry);
return temp;
}
bigInt bigInt::operator +(const bigInt& bi2)const
{
int sum;
int carry=0;
int k;
int len=this->digit.size();
bigInt temp;
if(len < bi2.digit.size())len=bi2.digit.size();
for(k=0;k < len; k++)
{
sum=this->digit[k]+bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push_back(sum);
}
if(carry != 0)temp.digit.push_back(carry);
return temp;
}
const bigInt& bigInt::operator =(long int i)
{
bigInt temp(i);
int k=0;
this->digit.resize(0);
while(k < temp.digit.size())
{
this->digit[k]=temp.digit[k];
k++;
}
return *this;
}
const bigInt& bigInt::operator =(const bigInt& bi2)
{
int i=0;
while(i < this->digit.size())
{
this->digit.pop_back();
i++;
}
this->digit.resize(0);
i=0;
while(i < bi2.digit.size())
{
this->digit[i]=bi2.digit[i];
i++;
}
return *this;
}
bool bigInt::operator ==(const bigInt& bi2)const
{
bool isIT=false;
if( bi2.digit.size() == this->digit.size() )
{
for(int i=0; i < this->digit.size();i++)
{
if(bi2.digit[i] != this->digit[i])return isIT;
}
isIT=true;
}
return isIT;;
}
bool bigInt::operator < (const bigInt& bi2)const
{
bool isIt=false;
if(this->digit.size() != bi2.digit.size())return( this->digit.size() < bi2.digit.size());
for(int i=0;i < this->digit.size();i++)
{
if(this->digit[i] < bi2.digit[i])return isIt=true;
}
return isIt;
}
testbigInt.cpp
Code:
#include <iostream>
#include "bigInt.h"
int main()
{
bigInt bi1/*("+19999999999999999999999999999999999")*/(9000), bi2;
++bi1;
bi1.print(cout);
cout<<endl;
cout<<"Enter a bigInt: ";
bi2.read(cin);
++bi2;
bi2.print(cout);
cout<<endl;
bi2.print(cout);
cout<<endl;
cin.get();
cin.get();
return 0;
}