PROGRAM 1

PROGRAM 1 // FILENAME: PROGRAM1.CPP AUTHOR: ANTHONY F. ORTIZ #include #include #include // DECLARATION FOR A LINKED LIST CLASS CALLED LIST. template class LIST { protected: // THE LIST IS A LINKED LIST WITH A HEADER NODE. struct NODE { ETYPE ELEMENT; NODE * NEXT; // CONSTRUCTOR FOR NODE. NODE (ETYPE E = 0, NODE * N = 0): ELEMENT (E), NEXT (N) {} }; NODE *LIST_HEAD; NODE *CURRENT_POS; void DELETE_LIST (); // THE CORRECT ROUTINE IN FIG. 3.16. LIST (LIST & VALUE); // DISABLE CALL BY VALUE. public: // CONSTRUCTOR. LIST () : LIST_HEAD (new NODE), CURRENT_POS (LIST_HEAD) {} // DESTRUCTOR. virtual ~LIST () {DELETE_LIST ();} // OPERATORS. const LIST & operator = (LIST & VALUE); const LIST & operator ++ (); int operator ! () const; const ETYPE & operator () () const; // MEMBER FUNCTIONS. int IS_EMPTY () const {return LIST_HEAD -> NEXT == 0;} virtual int FIND (const ETYPE & X); virtual int FIND_PREVIOUS (const ETYPE & X); int IN_LIST (const ETYPE & X); // NOT DEFINED; void FIRST () {if (LIST_HEAD -> NEXT != 0) CURRENT_POS = LIST_HEAD -> NEXT;} void HEADER () {CURRENT_POS = LIST_HEAD;} int REMOVE (const ETYPE & X); virtual void INSERT (const ETYPE & X); virtual void INSERT_AS_FIRST_ELEMENT (const ETYPE & X); }; // IMPLEMENTATION OF A LINKED LIST CALLED LIST. // DELETE AN ENTIRE LIST. // HEADER ASSUMED. template void LIST :: DELETE_LIST () { NODE * P = LIST_HEAD -> NEXT, * TEMP; while (P != 0) { TEMP = P -> NEXT; delete P; P = TEMP; } delete LIST_HEAD; } // DUPLICATE A LIST. // CURRENT POSITION BECOMES FIRST ELEMENT IN BOTH LISTS. template const LIST & LIST :: operator = (LIST & VALUE) { if (this == & VALUE) // DON'T COPY TO YOURSELF! return * this; DELETE_LIST (); CURRENT_POS = LIST_HEAD = new NODE; for (VALUE.FIRST (); !VALUE; ++VALUE) { CURRENT_POS -> NEXT = new NODE (VALUE (), CURRENT_POS -> NEXT); CURRENT_POS = CURRENT_POS -> NEXT; } CURRENT_POS -> NEXT = 0; FIRST (); VALUE.FIRST (); return *this; } // ADVANCE THE CURRENT POSITION. template inline const LIST & LIST :: operator ++ () { if (CURRENT_POS != 0) CURRENT_POS = CURRENT_POS -> NEXT; return * this; } // CHECK IF CURRENT POSITION IS NOT NULL. template inline int LIST :: operator ! () const { return CURRENT_POS != 0; } // RETRIEVE ELEMENT IN THE CURRENT POSITION. // RETURN VALUE IS UNDEFINED IF CURRENT POSITION IS NULL. template inline const ETYPE & LIST :: operator () () const { if (CURRENT_POS != 0) return CURRENT_POS -> ELEMENT; else return LIST_HEAD -> ELEMENT; } // ASSUMING USE OF HEADER NODE, FIND X. // IF FOUND, RETURN TRUE AND SET THE CURRENT POSITION. template int LIST :: FIND (const ETYPE & X) { NODE * P; for (P = LIST_HEAD -> NEXT; P != 0; P = P -> NEXT) { if (P -> ELEMENT == X) { CURRENT_POS = P; return 1; } } return 0; } // ASSUMING USE OF HEADER NODE, FIND X. // IF FOUND, RETURN TRUE AND SET THE CURRENT POSITION TO BEFORE X. template int LIST :: FIND_PREVIOUS (const ETYPE & X) { NODE * P; for (P = LIST_HEAD; P -> NEXT != 0; P = P -> NEXT) if (P -> NEXT -> ELEMENT == X) { CURRENT_POS = P; return 1; } return 0; } // REMOVE X FROM THE LIST. // RETURN NONZERO IF DELETION WAS SUCCESSFUL. // HEADER NODE IS ASSUMED. template int LIST :: REMOVE (const ETYPE & X) { NODE * CELL_TO_DELETE; if (FIND_PREVIOUS (X)) { CELL_TO_DELETE = CURRENT_POS -> NEXT; CURRENT_POS -> NEXT = CELL_TO_DELETE -> NEXT; delete CELL_TO_DELETE; return 1; } return 0; } // INSERT X AFTER THE CURRENT POSITION. // X BECOMES THE CURRENT ELEMENT. // HEADER IMPLEMENTATION ASSUMED. template void LIST :: INSERT (const ETYPE & X) { NODE * P = new NODE (X, CURRENT_POS -> NEXT); if (P == 0) cout << "OUT OF SPACE." << endl; else { CURRENT_POS -> NEXT = P; CURRENT_POS = CURRENT_POS -> NEXT; } } // INSERT X BEFORE THE CURRENT POSITION. // HEADER IMPLEMENTATION ASSUMED. template void LIST :: INSERT_AS_FIRST_ELEMENT (const ETYPE & X) { HEADER (); INSERT (X); } // DECLARATION FOR A ARBITRARY INTEGER PACKAGE CALLED INTEGER_PACKAGE. class INTEGER_PACKAGE { public: // CONSTRUCTOR. INTEGER_PACKAGE () {}; // DESTRUCTOR. ~INTEGER_PACKAGE () {}; // GET TWO STRINGS FROM THE KEYBOARD. // LATER, THEY WILL BE TURNED INTO INTEGER LINKED LISTS. GET_NUMBERS (char * SNUMBER1, char * SNUMBER2); // CONVERT THE STRINGS TO LINKED LISTS. CONVERT_TO_LINKED_LIST (char * SNUMBER1, char * SNUMBER2); // ADD THE LINKED LISTS AND PRINT THE RESULT. ADD_NUMBERS (); // EXACTLY THE SAME AS ADD_NUMBERS MEMBER FUNCTION. ADD_NUMBERS_FOR_MULT (); // SUBTRACT THE LINKED LISTS AND PRINT THE RESULT. SUBTRACT_NUMBERS (); // MULTIPLY THE LINKED LISTS AND PRINT THE RESULT. MULTIPLY_NUMBERS (); // DESTROY THE RESULT. DESTROY_RESULT (); private: // THIS WILL HOLD A LINE FROM THE MULTIPLICATION OF // TWO INTEGERS. LIST MULT1; // THIS WILL HOLD THE SUM OF ONE, TWO, OR SEVERAL LINES // FROM MULTIPLYING TWO INTEGERS. LIST MULT2; // THIS WILL ADD UP THE LINES WHEN MULTIPLYING TWO // INTEGERS. LIST ADD; // THE FIRST INTEGER. LIST LNUMBER1; // THE SECOND INTEGER. LIST LNUMBER2; // THE RESULT OF AN ADDITION OR SUBTRACTION OR // MULTIPLICATION. LIST RESULT; // THIS WILL TELL WHICH OF THE TWO INTEGERS IS BIGGER. // IT WILL BE USED FOR THE SUBTRACTION MEMBER FUNCTION. int FLAG; }; // ENTER TWO STRINGS FROM THE KEYBOARD. LATER, THEY WILL BE CONVERTED TO // TWO LINKED LISTS. INTEGER_PACKAGE :: GET_NUMBERS (char * SNUMBER1, char * SNUMBER2) { clrscr (); cout << "ENTER FIRST POSITIVE INTEGER. "; cin >> SNUMBER1; cout << endl; cout << "ENTER SECOND POSITIVE INTEGER. "; cin >> SNUMBER2; cout << endl; return 0; } // CONVERT THE TWO STRINGS TO LINKED LISTS. INTEGER_PACKAGE :: CONVERT_TO_LINKED_LIST (char * SNUMBER1, char * SNUMBER2) { // CONVERT FIRST STRING TO LINKED LIST. for (int I = 0; I < strlen (SNUMBER1); I++) { LNUMBER1.INSERT_AS_FIRST_ELEMENT (int (SNUMBER1 [I]) - 48); } // CONVERT SECOND STRING TO LINKED LIST. for (int J = 0; J < strlen (SNUMBER2); J++) { LNUMBER2.INSERT_AS_FIRST_ELEMENT (int (SNUMBER2 [J]) - 48); } // THIS WILL TELL WHICH OF THE TWO LINKED LISTS HOLDS THE // BIGGER NUMBERS. IF THE LENGTH OF INTEGER 2 IS LONGER, THEN // FLAG WILL BE EQUAL TO 1. THE LENGTH OF THE INTEGERS IS // REPRESENTED BY I AND J. IF THEY HAVE SIMILAR LENGTHS AND THE // SECOND NUMBER IS GREATED THEN THE FIRST NUMBER, THEN FLAG WILL BE // EQUAL TO 1. SNUMBER [0] AND SNUMBER [1] REPRESENTED THE MOST // SIGNIFICANT DIGIT. if (J > I || (J == I && int (SNUMBER2 [0]) - 48 > int (SNUMBER1 [0]) - 48)) { FLAG = 1; } else { FLAG = 0; } return 0; } // ADD TWO LINKED LISTS AND DISPLAY THE ANSWER. INTEGER_PACKAGE :: ADD_NUMBERS () { // THIS WILL BE THE REMAINDER FOR EACH ADDITION OF THE LINKED // LIST. int REMAINDER = 0; // THIS WILL BE THE SUM OF EACH DIGIT WITH 10 BEING TAKEN OUT // WHEN THE TWO INTEGERS SUM IS GREATER THAN 10. int ANSWER; // START AT THE FIRST INTEGER OF THE LINKED LIST. LNUMBER1.FIRST (); // START AT THE SECOND INTEGER OF THE LINKED LIST. LNUMBER2.FIRST (); // WHEN THEY ARE BOTH EQUAL TO THE HEADER, QUIT. while (!LNUMBER1 || !LNUMBER2) { // IF THEY ARE BOTH NOT EQUAL TO THE HEADER, SUM // THE CURRENT TWO INTEGERS IN THE LINKED LIST. if (!LNUMBER1 && !LNUMBER2) { // EACH DIGIT WILL EQUAL REMAINDER + CURRENT // INTEGER ONE + CURRENT INTEGER TWO. ANSWER = REMAINDER + LNUMBER1 () + LNUMBER2 (); // IF THE ANSWER IF GREATER THAN 10, // TAKE AWAY 10 FROM THE ANSWER AND ADD 1 TO // THE REMAINDER ELSE REMAINDER EQUALS 0. if (ANSWER >= 10) { ANSWER = ANSWER - 10; REMAINDER = 1; } else { REMAINDER = 0; } // INSERT THE ANSWER INTO THE CURRENT LINKED LIST // ENTRY. RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); // GO TO NEXT NUMBERS IN THE LINKED LIST ++LNUMBER1; ++LNUMBER2; ++RESULT; } // WHEN THE SECOND NUMBER IS NOT EQUAL TO THE HEADER // ADD THE SECOND NUMBER + THE REMAINDER. else if (!LNUMBER2) { // EACH DIGIT WILL EQUAL REMAINDER + SECOND NUMBER. ANSWER = REMAINDER + LNUMBER2 (); // IF THE ANSWER IF GREATER THAN 10, // TAKE AWAY 10 FROM THE ANSWER AND ADD 1 TO // THE REMAINDER ELSE REMAINDER EQUALS 0. if (ANSWER >= 10) { ANSWER = ANSWER - 10; REMAINDER = 1; } else { REMAINDER = 0; } // INSERT THE ANSWER INTO THE CURRENT LINKED LIST // ENTRY. RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); // GO TO NEXT NUMBERS IN THE LINKED LIST ++LNUMBER2; ++RESULT; } // WHEN THE FIRST NUMBER IS NOT EQUAL TO THE HEADER // ADD THE FIRST NUMBER + THE REMAINDER. else if (!LNUMBER1) { // EACH DIGIT WILL EQUAL REMAINDER + FIRST NUMBER. ANSWER = REMAINDER + LNUMBER1 (); // IF THE ANSWER IF GREATER THAN 10, // TAKE AWAY 10 FROM THE ANSWER AND ADD 1 TO // THE REMAINDER ELSE REMAINDER EQUALS 0. if (ANSWER >= 10) { ANSWER = ANSWER - 10; REMAINDER = 1; } else { REMAINDER = 0; } // INSERT THE ANSWER INTO THE CURRENT LINKED LIST // ENTRY. RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); // GO TO NEXT NUMBERS IN THE LINKED LIST ++LNUMBER1; ++RESULT; } } // IF REMAINDER IS EQUAL TO 1, THEN INSERT THE REMAINDER INTO // LINKED LIST. if (REMAINDER == 1) { ANSWER = REMAINDER; RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); } // PRINT THE RESULT. for (RESULT.FIRST (); !RESULT; ++RESULT) { cout << RESULT (); } cout << endl << endl; return 0; } // EXACTLY THE SAME AS THE MEMBER FUNCTION ADD_NUMBERS () EXCEPT THIS WILL // BE USED WITH ADDING MULTIPLICATION LINES. INTEGER_PACKAGE :: ADD_NUMBERS_FOR_MULT () { int REMAINDER = 0; int ANSWER; MULT1.FIRST (); MULT2.FIRST (); while (!MULT1 || !MULT2) { if (!MULT1 && !MULT2) { ANSWER = REMAINDER + MULT1 () + MULT2 (); if (ANSWER >= 10) { ANSWER = ANSWER - 10; REMAINDER = 1; } else { REMAINDER = 0; } ADD.INSERT_AS_FIRST_ELEMENT (ANSWER); ++MULT1; ++MULT2; ++ADD; } else if (!MULT2) { ANSWER = REMAINDER + MULT2 (); if (ANSWER >= 10) { ANSWER = ANSWER - 10; REMAINDER = 1; } else { REMAINDER = 0; } ADD.INSERT_AS_FIRST_ELEMENT (ANSWER); ++MULT2; ++ADD; } else if (!MULT1) { ANSWER = REMAINDER + MULT1 (); if (ANSWER >= 10) { ANSWER = ANSWER - 10; REMAINDER = 1; } else { REMAINDER = 0; } ADD.INSERT_AS_FIRST_ELEMENT (ANSWER); ++MULT1; ++ADD; } } if (REMAINDER == 1) { ANSWER = REMAINDER; ADD.INSERT_AS_FIRST_ELEMENT (ANSWER); } return 0; } // SUBTRACT TWO LINKED LISTS AND DISPLAY THE RESULT. INTEGER_PACKAGE :: SUBTRACT_NUMBERS () { // THIS WILL BE THE REMAINDER FOR EACH SUBTRACTION IN THE // LINKED LIST. int REMAINDER = 0; // THIS WILL BE THE SUBTRACTION OF EACH DIGIT WITH 10 BEING ADDED // WHEN THE TWO INTEGERS SUM IS LESS THAN 0. int ANSWER; // START AT THE FIRST INTEGER OF THE LINKED LIST. LNUMBER1.FIRST (); // START AT THE SECOND INTEGER OF THE LINKED LIST. LNUMBER2.FIRST (); // IF FLAG = 1, THEN MAKE LNUMBER1 = LNUMBER2 AND // LNUMBER2 = LNUMBER1. LATER, WE WILL PUT A - // ON THE END OF THE LINKED LIST'S RESULT. if (FLAG == 1) { LIST TEMP1; LIST TEMP2; TEMP1 = LNUMBER1; TEMP2 = LNUMBER2; LNUMBER1 = TEMP2; LNUMBER2 = TEMP1; } // QUIT WHEN THEY BOTH DON'T HEADER. while (!LNUMBER1 || !LNUMBER2) { // WHEN THEY BOTH EQUAL HEADER, SUBTRACT THE CURRENT // SECOND INTEGER AND CURRENT REMAINDER FROM THE // CURRENT FIRST INTEGER. if (!LNUMBER1 && !LNUMBER2) { ANSWER = LNUMBER1 () - LNUMBER2 () - REMAINDER; // IF ANSWER < 0, THEN ADD 10 TO THE ANSWER // AND 1 TO THE REMAINDER ELSE REMAINDER = 0. if (ANSWER < 0) { ANSWER = ANSWER + 10; REMAINDER = 1; } else { REMAINDER = 0; } // INSERT THE ANSWER INTO THE FIRST ELEMENT // OF THE LINKED LIST RESULT. RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); // GO TO THE NEXT NUMBERS. ++LNUMBER1; ++LNUMBER2; ++RESULT; } // WHEN LINKED LIST NUMBER1 = HEADER, THEN SUBTRACT THE // REMAINDER FROM THE CURRENT SECOND INTEGER. else if (!LNUMBER2) { ANSWER = LNUMBER2 () - REMAINDER; // IF ANSWER < 0, THEN ADD 10 TO THE ANSWER // AND 1 TO THE REMAINDER ELSE REMAINDER = 0. if (ANSWER < 0) { ANSWER = ANSWER + 10; REMAINDER = 1; } else { REMAINDER = 0; } // INSERT THE ANSWER INTO THE FIRST ELEMENT // OF THE LINKED LIST RESULT. RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); // GO TO THE NEXT NUMBERS. ++LNUMBER2; ++RESULT; } // WHEN LINKED LIST NUMBER2 = HEADER, THEN SUBTRACT THE // REMAINDER FROM THE CURRENT FIRST INTEGER. else if (!LNUMBER1) { ANSWER = LNUMBER1 () - REMAINDER; // IF ANSWER < 0, THEN ADD 10 TO THE ANSWER // AND 1 TO THE REMAINDER ELSE REMAINDER = 0. if (ANSWER < 0) { ANSWER = ANSWER + 10; REMAINDER = 1; } else { REMAINDER = 0; } // INSERT THE ANSWER INTO THE FIRST ELEMENT // OF THE LINKED LIST RESULT. RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); // GO TO NEXT NUMBERS. ++LNUMBER1; ++RESULT; } } // REMOVE THE 0'S FROM THE BEGINNING OF THE RESULT. for (RESULT.FIRST (); RESULT () == 0; ++RESULT) { RESULT.REMOVE (0); } // IF FLAG = 1, THEN REMOVE THE FIRST ELEMENT AND INSERT // THE NEGATIVE OF THIS ELEMENT. if (FLAG == 1) { ANSWER = RESULT (); RESULT.REMOVE (ANSWER); RESULT.INSERT_AS_FIRST_ELEMENT (-ANSWER); } // PRINT THE RESULT. for (RESULT.FIRST (); !RESULT; ++RESULT) { cout << RESULT (); } cout << endl << endl; return 0; } // MULTIPLY TWO LINKED LISTS AND PRINT THE RESULT. INTEGER_PACKAGE :: MULTIPLY_NUMBERS () { // THIS WILL BE THE MULTIPLICATION OF EACH DIGIT WITH A NUMBER // BEING SUBTRACTED IF THE ANSWER IS GREATER THEN 10. int ANSWER; // THIS WILL BE THE REMAINDER FOR EACH MULTIPLICATION IN THE // LINKED LIST. int REMAINDER = 0; // THIS WILL BE TRACK OF HOW MANY 0'S YOU HAVE TO ADD TO // THE VARIOUS MULTIPLICATION LINES. int COUNT = 0; LIST RESULT; // GO TO THE FIRST INTEGER OF RESULT. RESULT.FIRST (); LNUMBER2.FIRST (); // THE NEXT TWO FOR LOOPS WILL MULTIPLY THE TWO NUMBERS. for (LNUMBER2.FIRST (); !LNUMBER2; ++LNUMBER2) { // UPDATE COUNT. COUNT = COUNT + 1; // ADD 0'S TO THE MULTIPLICATION LINE. for (int I = 2; I <= COUNT; I++) { RESULT.INSERT_AS_FIRST_ELEMENT (0); ++RESULT; } for (LNUMBER1.FIRST (); !LNUMBER1; ++ LNUMBER1) { // ANSWER = THE CURRENT INTEGER OF // LINKED LIST 1 * THE CURRENT INTEGER OF // LINKED LIST 2 + REMAINDER. ANSWER = LNUMBER1 () * LNUMBER2 () + REMAINDER; // IF ANSWER >= 10 THEN REMAINDER WILL // EQUAL THE FLOOR OF ANSWER / 10 AND // THE ANSWER WILL ANSWER SUBTRACTED FROM // REMAINDER * 10. if (ANSWER >= 10) { REMAINDER = int (ANSWER / 10); ANSWER = ANSWER - REMAINDER * 10; } else { REMAINDER = 0; } // INSERT THE ANSWER INTO THE FIRST ELEMENT // OF THE LINKED LIST RESULT. RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); // GO TO NEXT NUMBER. ++RESULT; } // IF REMAINDER >= 0, THEN INSERT THE REMAINDER INTO // THE ANSWER. if (REMAINDER > 0) { ANSWER = REMAINDER; RESULT.INSERT_AS_FIRST_ELEMENT (ANSWER); REMAINDER = 0; } // COPY ADD TO MULT1. MULT1 WILL CONTAIN THE NEXT MULTIPLICATION // LINE. for (RESULT.FIRST (); !RESULT; ++RESULT) { MULT1.INSERT_AS_FIRST_ELEMENT (RESULT ()); } // COPY ADD TO MULT2. MULT2 WILL CONTAIN THE ADDITION OF THE // MULTIPLICATION LINES. for (ADD.FIRST (); !ADD; ++ADD) { MULT2.INSERT_AS_FIRST_ELEMENT (ADD ()); } // REMOVE ADD BECAUSE IT WILL EFFECT NEXT ADDITION. for (RESULT.FIRST (); !RESULT; ++RESULT) { RESULT.REMOVE (RESULT ()); } // REMOVE ADD BECAUSE IT WILL EFFECT NEXT ADDITION. for (ADD.FIRST (); !ADD; ++ADD) { ADD.REMOVE (ADD ()); } // ADD THE MULTIPLICATION LINES. STORE ANSWER IN THE LINKED // LIST CALLED ADD. ADD_NUMBERS_FOR_MULT (); // DELETE MULT1 BECAUSE IT WILL EFFECT THE NEXT ADDITION. for (MULT1.FIRST (); !MULT1; ++MULT1) { MULT1.REMOVE (MULT1 ()); } // DELETE MULT2 BECAUSE IT WILL EFFECT THE NEXT ADDITION. for (MULT2.FIRST (); !MULT2; ++MULT2) { MULT2.REMOVE (MULT2 ()); } } // RESULT SHOULD EQUAL THE LAST ADD. RESULT = ADD; // PRINT THE RESULT. for (RESULT.FIRST (); !RESULT; ++RESULT) { cout << RESULT (); } return 0; } // DESTROY THE LINKED LIST RESULT. INTEGER_PACKAGE :: DESTROY_RESULT () { for (RESULT.FIRST (); !RESULT; ++RESULT) { RESULT.REMOVE (RESULT ()); } return 0; } // THIS PROGRAM ADD, SUBTRACTS, AND MULTIPLIES ANY TWO ARBITRARY INTEGERS // USING THE LIST CLASS AND THE INTEGER_PACKAGE CLASS. main () { // DECLARE TWO STRINGS WHICH WILL BE INPUT FROM THE KEYBOARD. // LATER, THEY WILL BE CHANGED INTO TWO LINKED LISTS. char SNUMBER1 [4001]; char SNUMBER2 [4001]; // AOPERATION WILL BE USED TO GET STRINGS FROM KEYBOARD, // CONVERT THEM TO TWO INTEGER LINKED, AND THEN ADD // SUBTRACT, AND MULTIPLY THEM. INTEGER_PACKAGE AOPERATION; // GET TWO STRINGS FROM THE KEYBOARD. AOPERATION.GET_NUMBERS (SNUMBER1, SNUMBER2); // CONVERT THEM TO A INTEGER LINKED LIST. AOPERATION.CONVERT_TO_LINKED_LIST (SNUMBER1, SNUMBER2); // ADD THE NUMBERS AND DISPLAY RESULT. cout << "ADD RESULT: "; AOPERATION.ADD_NUMBERS (); // DESTROYS THE RESULT. AOPERATION.DESTROY_RESULT (); // SUBTRACT THE NUMBERS AND DISPLAY RESULT. cout << "SUBTRACT RESULT: "; AOPERATION.SUBTRACT_NUMBERS (); // DESTROY RESULT. AOPERATION.DESTROY_RESULT (); // MULTIPY THE NUMBERS AND DISPLAY RESULT. cout << "MULTIPLY RESULT: "; AOPERATION.MULTIPLY_NUMBERS (); return 0; } // OUTFILE: PROG1.OUT ENTER FIRST POSITIVE INTEGER. 123456789012345678901234567890 ENTER SECOND POSITIVE INTEGER. 234567890123456789012345678901 ADD RESULT: 358024679135802467913580246791 SUBTRACT RESULT: -111111101111111110111111111011 MULTIPLY RESULT: 289589985200426886037189477354854446640313976776514250888 90 BACK TO CS3240 PAGE.