Hi, im working on this bigInt class. Need help writing algorithm for
the operator*, andy help will be appreciated. Thanks in advance
bigInt.h
=============== =============== =============== =============== =============== ========
//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==(cons t 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(c onst string& s); //converts string into bigInt
//representaion., defined
};
//overloads << and >> operators as non-member functions using
//public member functions print and read.
ostream& operator<<(ostr eam& os, const bigInt& bi); //defined
istream& operator>>(istr eam& is, bigInt& bi);//defined
#endif
=============== =============== =============== =============== =============== ======
bigInt2.cpp
=============== =============== =============== =============== =============== ======
#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(o stream& 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(is tream& is)
{ string s;
is>>s;
convertString(s );
}
bigInt& bigInt::operato r++() //++ 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::convert String(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::operato r *(const bigInt& bi2)const
{
int mul;
int carry=0;
int k;
int len=this->digit.size() ;
bigInt tem;
for(k=0;k<len;k ++)
{
mul=(digit[k]*bi2.digit[k])+carry;
carry=mul/10;
mul=mul%10;
tem.digit.push_ back(mul);
}
if(carry != 0)tem.digit.pus h_back(carry);
tem.sign='+';
return tem;
}
bigInt bigInt::operato r +(const bigInt& bi2)const//works only for both
numbers positive.
{
int sum;
int carry=0;
int k;
int len=digit.size( );
bigInt temp;
if(digit.size() == bi2.digit.size( ))//this addition to take place if
both numbers are of equal length.
{
for(k=0;k < len; k++)
{
sum=digit[k]+bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
if(carry != 0)temp.digit.pu sh_back(carry);
}//end of code for addition if both numbers are equal.
if(digit.size() < bi2.digit.size( ))//if this has fewer numbers
{
for(k=0;k < digit.size();k+ +)//this loop will go on till the one
with fewer numbers will be exhausted
{
sum=digit[k]+bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
for(k=digit.siz e();k<bi2.digit .size();k++)//this will work on the
left over digits of the big digit.
{
sum=bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
if(carry != 0)temp.digit.pu sh_back(carry);
}
if(bi2.digit.si ze() < digit.size())//if bi2 is the smaller number,
then it will be on the bottom.
{
for(k=0;k<bi2.d igit.size();k++ )
{
sum=digit[k]+bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
for(k=bi2.digit .size();k<digit .size();k++)//this will work on the
left over digits of big int.
{
sum=digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
if(carry != 0)temp.digit.pu sh_back(carry);
}
temp.sign='+';
return temp;
}
const bigInt& bigInt::operato r =(long int i)
{
bigInt temp(i);
int k=0;
digit.erase(thi s->digit.begin( ), this->digit.end()) ;
while(k < temp.digit.size ())
{
this->digit[k]=temp.digit[k];
k++;
}
this->sign='+';
return *this;
}
const bigInt& bigInt::operato r =(const bigInt& bi2)
{
int size = bi2.digit.size( ); // get vector size
digit.erase(thi s->digit.begin( ), this->digit.end()) ; // erase current
vector
this->digit.resize(s ize); // set new vector size
for(int i= 0; i < size; i++)
{
this->digit[i]=bi2.digit[i];
}
this->sign='+';
return *this;
}
bool bigInt::operato r ==(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::operato r < (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
=============== =============== =============== =============== =============== ======
#include<iostre am>
#include "bigInt.h"
using namespace std;
int main(){
bigInt bi1("+199999999 999999999999999 99999999999");
bigInt bi3(2);
bigInt bi2(21);
cout << "bi1: " << bi1 << endl;
cout << "bi2: " << bi2 << endl;
cout << "bi3: " << bi3 << endl;
cout << "bi2 + bi3: " << bi2*bi3 << endl;
return 0;
}
=============== =============== =============== =============== =============== ======
the operator*, andy help will be appreciated. Thanks in advance
bigInt.h
=============== =============== =============== =============== =============== ========
//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==(cons t 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(c onst string& s); //converts string into bigInt
//representaion., defined
};
//overloads << and >> operators as non-member functions using
//public member functions print and read.
ostream& operator<<(ostr eam& os, const bigInt& bi); //defined
istream& operator>>(istr eam& is, bigInt& bi);//defined
#endif
=============== =============== =============== =============== =============== ======
bigInt2.cpp
=============== =============== =============== =============== =============== ======
#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(o stream& 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(is tream& is)
{ string s;
is>>s;
convertString(s );
}
bigInt& bigInt::operato r++() //++ 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::convert String(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::operato r *(const bigInt& bi2)const
{
int mul;
int carry=0;
int k;
int len=this->digit.size() ;
bigInt tem;
for(k=0;k<len;k ++)
{
mul=(digit[k]*bi2.digit[k])+carry;
carry=mul/10;
mul=mul%10;
tem.digit.push_ back(mul);
}
if(carry != 0)tem.digit.pus h_back(carry);
tem.sign='+';
return tem;
}
bigInt bigInt::operato r +(const bigInt& bi2)const//works only for both
numbers positive.
{
int sum;
int carry=0;
int k;
int len=digit.size( );
bigInt temp;
if(digit.size() == bi2.digit.size( ))//this addition to take place if
both numbers are of equal length.
{
for(k=0;k < len; k++)
{
sum=digit[k]+bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
if(carry != 0)temp.digit.pu sh_back(carry);
}//end of code for addition if both numbers are equal.
if(digit.size() < bi2.digit.size( ))//if this has fewer numbers
{
for(k=0;k < digit.size();k+ +)//this loop will go on till the one
with fewer numbers will be exhausted
{
sum=digit[k]+bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
for(k=digit.siz e();k<bi2.digit .size();k++)//this will work on the
left over digits of the big digit.
{
sum=bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
if(carry != 0)temp.digit.pu sh_back(carry);
}
if(bi2.digit.si ze() < digit.size())//if bi2 is the smaller number,
then it will be on the bottom.
{
for(k=0;k<bi2.d igit.size();k++ )
{
sum=digit[k]+bi2.digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
for(k=bi2.digit .size();k<digit .size();k++)//this will work on the
left over digits of big int.
{
sum=digit[k]+carry;
carry=sum/10;
sum=sum%10;
temp.digit.push _back(sum);
}
if(carry != 0)temp.digit.pu sh_back(carry);
}
temp.sign='+';
return temp;
}
const bigInt& bigInt::operato r =(long int i)
{
bigInt temp(i);
int k=0;
digit.erase(thi s->digit.begin( ), this->digit.end()) ;
while(k < temp.digit.size ())
{
this->digit[k]=temp.digit[k];
k++;
}
this->sign='+';
return *this;
}
const bigInt& bigInt::operato r =(const bigInt& bi2)
{
int size = bi2.digit.size( ); // get vector size
digit.erase(thi s->digit.begin( ), this->digit.end()) ; // erase current
vector
this->digit.resize(s ize); // set new vector size
for(int i= 0; i < size; i++)
{
this->digit[i]=bi2.digit[i];
}
this->sign='+';
return *this;
}
bool bigInt::operato r ==(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::operato r < (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
=============== =============== =============== =============== =============== ======
#include<iostre am>
#include "bigInt.h"
using namespace std;
int main(){
bigInt bi1("+199999999 999999999999999 99999999999");
bigInt bi3(2);
bigInt bi2(21);
cout << "bi1: " << bi1 << endl;
cout << "bi2: " << bi2 << endl;
cout << "bi3: " << bi3 << endl;
cout << "bi2 + bi3: " << bi2*bi3 << endl;
return 0;
}
=============== =============== =============== =============== =============== ======
Comment