myint.h:

// starter file for MyInt class header class MyInt { // these overload starters are declared as friend functions friend MyInt operator+ (const MyInt& x, const MyInt& y); // add in multiplication, as well friend bool operator 
 
 
myint.cpp:
 
#include  #include "myint.h" using namespace std; int C2I(char c) // converts character into integer (returns -1 for error) { if (c  '9') return -1; // error return (c - '0'); // success } char I2C(int x) // converts single digit integer into character (returns '\0' for error) { if (x  9) return '\0'; // error return (static_cast(x) + '0'); // success } // Add in operator overload and member function definitions Sample Main Program: 
 
// main.cpp // // Driver program to demonstrate the behavior of the MyInt class // // You can add more tests of your own, or write other drivers to test your // class #include  #include "myint.h" using namespace std; MyInt Fibonnaci(MyInt num); int main() { // demonstrate behavior of the two constructors and the > overload cout > x; cout > y; cout  y) cout  y) is TRUE "; if (x = y) cout = y) is TRUE "; if (x == y) cout  
 
 
Here are some sample runs:
 
Sample Run 1:
 
Sample run 2:
 
 
You can take your time and update me in the comments.
 
Thanks a lot for your assistance!
  This C++ dynamic memory allocation inside a class. Program consists of: operator overloading, as well as experience with managing Task One common limitation of programming languages is that the built-in types are limited to smaller finite ranges of storage. For instance, the built-in int type in C+ is 4 bytes in most systems today, allowing for about 4 billion different numbers. The regular int splits this range between positive and negative numbers, but even an unsigned int (assuming 4 bytes) is limited to the range 0 through 4,294,967,295. Heavy scientific computing applications often have the need for computing with larger numbers than the capacity of the normal integer types provided by the system. In C++, the largest integer type is long, but this still has an upper limit Your task will be to create a class, called MyInt, which will allow storage of any non-negative integer (theoretically without an upper limit -- although there naturally is an eventual limit to storage ina program). You will also provide some operator overloads, so that objects of type MyInt will act like regular integers, to some extent. There are many ways to go about creating such a class, but all will require dynamic allocation (since variables of this type should not have a limit on their capacity) The class, along with the required operator overloads, should be written in the files "myint.h" and "myint.cpp". I have provided starter versions of these files, along with some of the declarations you will need. You will need to add in others, and define all of the necessary functions. Here are the files