Question

C++ NEED AS SOON AS POSSIBLE!

BigInt class is used for the mathematical operations that involve very big integer calculations that are outside the limit of all available primitive data types. For example, factorial of 100 contains 158 digits in it so we can’t store it in any primitive data type available. We can store as large Integer as we want in it.
Your goal is to overload the operators for a generic “BigInt” class. You will need to write two files (BigInt.h and BigInt.cpp). Your implemented class must fully provide the definitions of following class (interface) functions .
class BigInt
{
//think about the private data members
public:
BigInt(int val = 0);
BigInt(const string& text);
BigInt(const BigInt& copy); // copy constructor
// Binary Operators
// Arithmetic Operators
BigInt operator+(const BigInt& val) const;
BigInt operator+(int val) const;
BigInt operator-(const BigInt& val) const;
BigInt operator-(int val) const;
BigInt operator*(const BigInt& val) const;
// Compound Assignment Operators
BigInt operator+=(const BigInt& rhs);
BigInt operator-=(const BigInt& rhs);
BigInt operator*=(const BigInt& rhs);
// Logical Operators
bool operator==(const BigInt& val) const;
bool operator!=(const BigInt& val) const;
bool operator<(const BigInt& val) const;
bool operator<=(const BigInt& val) const;
bool operator>(const BigInt& val) const;
bool operator>=(const BigInt& val) const

// Unary Operators
BigInt& operator++(); // Pre-increment Operator
BigInt operator++(int); // Post-increment Operator
BigInt& operator--(); // Pre-decrement Operator
BigInt operator--( int ); // Post-decrement Operator
//Conversion Operator
operator string(); // return value of the BigInt as string
~BigInt(); // destructor
};
ostream& operator<<(ostream& output, const BigInt& val); // outputs the BigInt
istream& operator>>(istream& input, BigInt& val); // inputs the BigInt

Your goal is to overload the operators for a generic “Polynomial” class. A polynomial will be represented via its coefficients. Here is a third degree polynomial 4x3 + 3x + 2; where we have four coefficients and the coefficient corresponding to 2nd power is zero. You are required to write two files (Polynomial.h and Polynomial.cpp). Your implemented class must fully provide the definitions of following class (interface) functions.
class Polynomial {
// think about the private data members (coefficient values can be of type int)
public:
//include all the necessary checks before performing the operations in the functions
Polynomial(); // a default constructor
Polynomial(int); // a parameterized constructor, received the highest degree of polynomial
Polynomial(const Polynomial &); // a copy constructor
// Binary Operators
// Assignment Operator
Polynomial operator=(const Polynomial& rhs); //assigns (copies) the rhs Polynomial to "this" Polynomial
// Arithmetic Operators
Polynomial operator+(const Polynomial &); // adds two Polynomials and returns the result
Polynomial operator-(const Polynomial &); // subtracts two Polynomials and returns the result
// Compound Assignment Operators
void operator+=(const Polynomial&); // adds two Polynomials
void operator-=(const Polynomial&); // subtracts two Polynomials
// Logical Operator
bool operator==(const Polynomial &); // compares and returns true if equal
// Conversion Operator
operator string() const; // returns the value of the Polynomial as a string like “4x^3 + 3x + 2”
~Polynomial(); // destructor
};

ostream& operator<<(ostream& output, const Polynomial&); // outputs the Polynomial istream& operator>>(istream& input, Polynomial&); // inputs the Polynomial

Answer 1

THIS IS THE QUESTION YOU ASKED FOR ITS WORKING PERFECTLY FINE

Comment down for any queries
Please give a thumbs up if you are satisfied with the answer

#ifndef BIGINT_H_
#define BIGINT_H_
#include <string>
using namespace std;
class BigInt
{
   static const int digitsPerSlot = 8;
static const int valuePerSlot = 100000000;
void copy(const BigInt & that);
void constructPointers();
slot * start;
slot * end;
int numberOfSlots;
void clear();
void put(int value);
void push(int value);
void add(const BigInt & that);
void subtract(const BigInt & that);
void removeLeadingZeros();
//think about the private data members
public:
BigInt(int val = 0);
BigInt(const string& text);
BigInt(const BigInt& copy); // copy constructor
// Binary Operators
// Arithmetic Operators
BigInt operator+(const BigInt& val) const;
BigInt operator+(int val) const;
BigInt operator-(const BigInt& val) const;
BigInt operator-(int val) const;
BigInt operator*(const BigInt& val) const;
// Compound Assignment Operators
BigInt operator+=(const BigInt& rhs);
BigInt operator-=(const BigInt& rhs);
BigInt operator*=(const BigInt& rhs);
// Logical Operators
bool operator==(const BigInt& val) const;
bool operator!=(const BigInt& val) const;
bool operator<(const BigInt& val) const;
bool operator<=(const BigInt& val) const;
bool operator>(const BigInt& val) const;
bool operator>=(const BigInt& val) const;
// Unary Operators
BigInt& operator++(); // Pre-increment Operator
BigInt operator++(int); // Post-increment Operator
BigInt& operator--(); // Pre-decrement Operator
BigInt operator--( int ); // Post-decrement Operator
//Conversion Operator
operator string();
// return value of the BigInt as string
~BigInt(); // destructor
};
ostream& operator<<(ostream& output, const BigInt& val); // outputs the BigInt
istream& operator>>(istream& input, BigInt& val); // inputs the BigInt
#endif /* BIGINT_H_ */

//CPP FILE OF BIG INT

#include<cstdlib>
#include "BigInt.h"
#include<iostream>
#include<string>
using namespace std;
BigInt::BigInt()
{
constructPointers();
}
BigInt::BigInt(int val)
{
constructPointers();
if (val < 0)
{
isPositive = false;
val *= -1;
}

if (val >= valuePerSlot)
{
put(val / valuePerSlot);
val %= valuePerSlot;
}
put(val);  
}
BigInt::BigInt(const string& text)
{
constructPointers();
int lengthOfString = 0;
while (string[lengthOfString] != '\0')
{
lengthOfString++;
}
int value = 0;
int index = 0;
if (string[0] == '-')
{
isPositive = false;
lengthOfString--;
index++;
}
while (lengthOfString)
{
if (!(lengthOfString % digitsPerSlot))
{
put(value);
value = 0;
}
value = value * 10 + (string[index] - '0');
lengthOfString--;
index++;
}
put(value);
}
BigInt::BigInt(const BigInt& copy) // copy constructor
{
constructPointers();
copy(copy);
}
// Binary Operators
// Arithmetic Operators

// Compound Assignment Operators
BigInt BigInt::operator+=(const BigInt& rhs)
{
if (isPositive && rhs.isPositive)
{
add(that);
}
else if (isPositive && !rhs.isPositive)
{
BigInt placeholder(rhs);
placeholder.isPositive = true;
subtract(placeholder);
}
else if (!isPositive && rhs.isPositive)
{
BigInt placeholder(rhs);
placeholder.subtract(*this);
copy(placeholder);
}
else
{
add(that);
isPositive = false;
}
return *this;
}
BigInt BigInt::operator+(const BigInt& val) const
{
   return *this+val;
}
BigInt BigInt::operator+(int val) const
{
   return *this+val;
}
BigInt BigInt::operator-(const BigInt& val) const
{
   return *this-val;
}
BigInt BigInt::operator-(int val) const
{
   return *this-val;
}
BigInt BigInt::operator*(const BigInt& val) const
{
   return *this*val;
}
BigInt BigInt::operator-=(const BigInt& rhs)
{
BigInt placeholder(rhs);
placeholder.isPositive = !placeholder.isPositive;
return *this += placeholder;
}
BigInt BigInt::operator*=(const BigInt& rhs)
{
   if (isPositive && that.isPositive)
{
add(that);
}
else if (isPositive && !that.isPositive)
{
BigInt placeholder(that);
placeholder.isPositive = true;
subtract(placeholder);
}
else if (!isPositive && that.isPositive)
{
BigInt placeholder(that);
placeholder.subtract(*this);
copy(placeholder);
}
else
{
add(that);
isPositive = false;
}
return *this;

}
// Logical Operators
bool BigInt::operator==(const BigInt& val) const
{
   if (this->numberOfSlots != val.numberOfSlots)
{
return false;
}
if (isPositive != val.isPositive)
{
return false;
}
slot * currentSlotThis = end;
slot * currentSlotThat = val.end;

while (currentSlotThis != nullptr)
{
if (currentSlotThis->value != currentSlotThat->value)
{
return false;
}
currentSlotThat = currentSlotThat->previous;
currentSlotThis = currentSlotThis->previous;
}
return true;
}
bool BigInt::operator!=(const BigInt& val) const
{
   return !(*this == val);
}
bool BigInt::operator<(const BigInt& val) const
{
   if (this->numberOfSlots != val.numberOfSlots || this->isPositive != val.isPositive)
{
return this->numberOfSlots * (this->isPositive - 0.5) < val.numberOfSlots * (that.isPositive - 0.5);
}

slot * currentSlotThis = start;
slot * currentSlotThat = val.start;
while (currentSlotThis->next != nullptr && currentSlotThis->value == currentSlotThat->value)
{
currentSlotThat = currentSlotThat->next;
currentSlotThis = currentSlotThis->next;
}
return currentSlotThis->value < currentSlotThat->value;
}
bool BigInt::operator<=(const BigInt& val) const
{
return !(val < *this);
}
bool BigInt::operator>(const BigInt& val) const
{
   return val < *this;
}
bool BigInt::operator>=(const BigInt& val) const
{
return !(*this < that);
}
// Unary Operators
BigInt& BigInt::operator++() // Pre-increment Operator
{
return *this += BigInt(1);
}
BigInt BigInt::operator++(int) // Post-increment Operator
{
   BigInt temp(*this);
operator++();
return temp;
}
BigInt& BigInt::operator--() // Pre-decrement Operator
{
   return *this -= BigInt(1);
}
BigInt BigInt::operator--( int ) // Post-decrement Operator
{
   BigInt temp(*this);
operator--();
return temp;  
}
//Conversion Operator
operator BigInt::string()
{
   return string;
}
// return value of the BigInt as string
BigInt::~BigInt()// destructor
{
clear();
}
ostream& operator<<(ostream& output, const BigInt& val)
{
   if (!val.isPositive)
{
output.put('-');
}

slot * currentSlot = val.start;
while (currentSlot != nullptr)
{
int value = currentSlot->value;
int fullValue = value;
int numberOfPaddingZeros = 1;
int digit = 10000000;
if (currentSlot == val.start && (fullValue == 0))
{
output.put('0');
}
else
{
while (digit)
{
// Pad the value in the slot with leading zeros to fill the entire slot, except when it is the first slot.
if (currentSlot != val.start || (fullValue >= digit))
{
output.put((value / digit) + '0');
}

value %= digit;
digit /= 10;
}
}
currentSlot = currentSlot->next;
}
return output;

} // outputs the BigInt

//POLYNOMIAL HEADER

#ifndef POLYNOMIAL_H_
#define POLYNOMIAL_H_

#include <string>
using namespace std;

class Polynomial
{
private:
   int d;
   int *ptr;

public:

Polynomial(); // a default constructor
Polynomial(int degree); // a parameterized constructor, received the highest degree of polynomial
Polynomial(const Polynomial &obj); // a copy constructor

int getDegree() const;
void addData(int data,int index);

void printData() const;

// Binary Operators
// Assignment Operator
Polynomial operator=(const Polynomial& rhs); //assigns (copies) the rhs Polynomial to "this" Polynomial
// Arithmetic Operators
Polynomial operator+(const Polynomial &rhs); // adds two Polynomials and returns the result
Polynomial operator-(const Polynomial &rhs); // subtracts two Polynomials and returns the result
// Compound Assignment Operators
void operator+=(const Polynomial& rhs); // adds two Polynomials
void operator-=(const Polynomial& rhs); // subtracts two Polynomials
// Logical Operator
bool operator==(const Polynomial &rhs); // compares and returns true if equal

// Conversion Operator
operator string() const; // returns the value of the Polynomial as a string like “4x^3 + 3x + 2”
~Polynomial(); // destructor
};

ostream& operator<<(ostream& output, const Polynomial& rhs); // outputs the Polynomial
istream& operator>>(istream& input, Polynomial& rhs); // inputs the Polynomial

#endif /* POLYNOMIAL_H_ */

//POLYNOMIAL CPP

#include<cstdlib>
#include "Polynomial.h"
#include<iostream>
#include<string>
using namespace std;

Polynomial::Polynomial() // a default constructor
{
   d=3;
   ptr=new int[d+1];
}
Polynomial::Polynomial(int degree) // a parameterized constructor, received the highest degree of polynomial
{
   d=degree;
   ptr=new int[d+1];
}
Polynomial::Polynomial(const Polynomial &obj) // a copy constructor
{
   this->d=obj.d;
   this->ptr=new int[d+1];
   for(int i=0;i<=d;i++)
   {
       this->ptr[i]=obj.ptr[i];
   }
}

int Polynomial::getDegree() const
{
   return d;
}

void Polynomial::addData(int data,int index)
{
   if(index>=0 && index<=d)
   {
       ptr[index]=data;
   }

}

void Polynomial::printData()const
{
   string poly;
       for(int i=d;i>=0;i--)
       {
           if(ptr[i]!=0)
           {
               poly= to_string(ptr[i])+"x^" + to_string(i);

               cout<<poly;
               if(i>0)
               {
                   cout<<"+";
               }

           }

       }
       cout<<endl;

}
// Binary Operators
// Assignment Operator
Polynomial Polynomial::operator=(const Polynomial& rhs) //assigns (copies) the rhs Polynomial to "this" Polynomial
{
   if(this==&rhs)
   {
       return *this;
   }
   if(ptr!=NULL)
   {
       delete [] ptr;
   }

       d=rhs.d;
       this->ptr=new int[d];

       for(int i=0;i<=d;i++)
       {
           this->ptr[i]=rhs.ptr[i];
       }

       return *this;

}
// Arithmetic Operators
Polynomial Polynomial::operator+(const Polynomial &rhs) // adds two Polynomials and returns the result
{

   if(d != rhs.d)
   {
       return *this;
   }

   Polynomial toReturn(d);

       for(int i=0;i<=d;i++)
       {
           toReturn.ptr[i]=ptr[i] + rhs.ptr[i];
       }

       return toReturn;

}
Polynomial Polynomial::operator-(const Polynomial &rhs) // subtracts two Polynomials and returns the result
{
   if(d != rhs.d)
   {
       return *this;
   }

   Polynomial toReturn(d);

       for(int i=0;i<=d;i++)
       {
           toReturn.ptr[i]=ptr[i] - rhs.ptr[i];
       }

       return toReturn;
}
// Compound Assignment Operators
void Polynomial::operator+=(const Polynomial& rhs) // adds two Polynomials
{
   *this=*this+rhs;
}
void Polynomial::operator-=(const Polynomial& rhs) // subtracts two Polynomials
{
   *this=*this- rhs;

}
// Logical Operator
bool Polynomial::operator==(const Polynomial &rhs) // compares and returns true if equal
{
   if(d==rhs.d)
   {
       for(int i=0;i<=d;i++)
       {
           if(ptr[i] != rhs.ptr[i])
           {
               return false;
           }
       }

       return true;
   }

   else
   {
       return false;
   }
}

// Conversion Operator
Polynomial::operator string() const // returns the value of the Polynomial as a string like “4x^3 + 3x + 2”
{
   string poly;
   string final;
   for(int i=d;i>=0;i--)
   {
       if(ptr[i]!=0)
       {
           poly= to_string(ptr[i])+"x^" + to_string(d);
       }

       final+=poly;

   }
   return final;

}
Polynomial::~Polynomial() // destructor
{
   delete [] ptr;
}

ostream& operator<<(ostream& output, const Polynomial& rhs) // outputs the Polynomial
{

   rhs.printData();

   return output;

}

istream& operator>>(istream& input, Polynomial& rhs) // inputs the Polynomial
{
   int data;
   int degree;
   cout<<"Enter number of the heighst degree #";
   cin>>degree;
   cout<<endl;
   for(int i=0;i<=degree;i++)
   {
       cout<<"Enter coffecient of "<<i<<endl;
       cin>>data;
       rhs.addData(data,i);

   }

   return input;

}

Comment down for any queries
Please give a thumbs up if you are satisfied with the answer