Solutions for H5. Lecture: Xu-Ying Liu

Transcription

1 Lecture: Xu-Ying Liu Ex // Exercise Solution: DoubleSubscriptedArray.h 2 // DoubleSubscriptedArray class for storing 3 // double subscripted arrays of integers. 4 #ifndef DOUBLE_SUBSCRIPTED_ARRAY_H 5 #define DOUBLE_SUBSCRIPTED_ARRAY_H 6 7 #include <iostream> 8 using namespace std; 9 10 class DoubleSubscriptedArray 11 { 12 friend ostream &operator<<( 13 ostream &, const DoubleSubscriptedArray & ); 14 friend istream &operator>>( istream &, DoubleSubscriptedArray & ); 15 public: 16 DoubleSubscriptedArray( int = 3, int = 3 ); // default constructor // copy constructor 19 DoubleSubscriptedArray( const DoubleSubscriptedArray & ); ~DoubleSubscriptedArray(); // destructor 22 int getrowsize() const; // return number of rows 23 int getcolumnsize() const; // return number of columns const DoubleSubscriptedArray &operator=( 26 const DoubleSubscriptedArray & ); // assignment operator // equality operator 29 bool operator==( const DoubleSubscriptedArray & ) const; // inequality operator; returns opposite of == operator 32 bool operator!=( const DoubleSubscriptedArray &right ) const 33 { 34 // invokes DoubleSubscriptedArray::operator== 35 return!( *this == right ); 36 } // end function operator!=

2 37 38 // function call operator for non-const objects 39 // returns modifiable lvalue 40 int &operator()( int, int ); // function call operator for const objects returns rvalue 43 int operator()( int, int ) const; 44 private: 45 int rowsize; // number of rows in array 46 int columnsize; // number of columns in array 47 int *ptr; // pointer to first element of pointer-based array 48 }; // end class DoubleSubscriptedArray #endif 1 // Exercise Solution: DoubleSubscriptedArray.cpp 2 // DoubleSubscriptedArray class member- and friend-function definitions. 3 #include <iostream> 4 #include <iomanip> 5 #include <cstdlib> // exit function prototype 6 #include "DoubleSubscriptedArray.h" // DoubleSubscriptedArray definition 7 using namespace std; 8 9 // default constructor for class DoubleSubscriptedArray 10 DoubleSubscriptedArray::DoubleSubscriptedArray( 11 int rowsizeentered, int columnsizeentered ) 12 { 13 // validate row and column size 14 rowsize = ( rowsizeentered > 0? rowsizeentered : 3 ); 15 columnsize = ( columnsizeentered > 0? columnsizeentered : 3 ); ptr = new int[ rowsize * columnsize ]; // create space for array for ( int loop = 0; loop < rowsize * columnsize; loop++ ) 20 ptr[ loop ] = 0; // set pointer-based array element 21 } // end DoubleSubscriptedArray default constructor // copy constructor for class DoubleSubscriptedArray; 24 // must receive a reference to prevent infinite recursion 25 DoubleSubscriptedArray::DoubleSubscriptedArray( 26 const DoubleSubscriptedArray &arraytocopy ) 27 : rowsize( arraytocopy.rowsize ), columnsize( arraytocopy.columnsize ) 28 { 29 ptr = new int[ rowsize * columnsize ]; // create space for array 30 2

3 31 for ( int loop = 0; loop < rowsize * columnsize; loop++ ) 32 ptr[ loop ] = arraytocopy.ptr[ loop ]; // copy into object 33 } // end DoubleSubscriptedArray copy constructor // destructor for class DoubleSubscriptedArray 36 DoubleSubscriptedArray::~DoubleSubscriptedArray() 37 { 38 delete [] ptr; // release pointer-based array space 39 } // end destructor // return number of rows of DoubleSubscriptedArray 42 int DoubleSubscriptedArray::getRowSize() const 43 { 44 return rowsize; // number of rows in DoubleSubscriptedArray 45 } // end function getrowsize // return number of columns of DoubleSubscriptedArray 48 int DoubleSubscriptedArray::getColumnSize() const 49 { 50 return columnsize; // number of columns in DoubleSubscriptedArray 51 } // end function getcolumnsize // overloaded assignment operator; 54 // const return avoids: ( a1 = a2 ) = a3 55 const DoubleSubscriptedArray &DoubleSubscriptedArray::operator=( 56 const DoubleSubscriptedArray &right ) 57 { 58 if ( &right!= this ) // avoid self-assignment 59 { 60 // for arrays of different sizes, deallocate original 61 // left-side array, then allocate new left-side array 62 if ( rowsize * columnsize!= right.rowsize * right.columnsize ) 63 { 64 delete [] ptr; // release space 65 rowsize = right.rowsize; // resize this object 66 columnsize = right.columnsize; 67 ptr = new int[ rowsize * columnsize ]; // create space for copy 68 } // end inner if for ( int loop = 0; loop < rowsize * columnsize; loop++ ) 71 ptr[ loop ] = right.ptr[ loop ]; // copy into object 72 } // end outer if return *this; // enables x = y = z, for example 75 } // end function operator= 76 3

4 77 // determine if two DoubleSubscriptedArrays are equal and 78 // return true, otherwise return false 79 bool DoubleSubscriptedArray::operator==( 80 const DoubleSubscriptedArray &right ) const 81 { 82 if ( rowsize * columnsize!= right.rowsize * right.columnsize ) 83 return false; // arrays of different number of elements for ( int loop = 0; loop < rowsize * columnsize; loop++ ) 86 if ( ptr[ loop ]!= right.ptr[ loop ] ) 87 return false; // DoubleSubscriptedArray contents are not equal return true; // DoubleSubscriptedArrays are equal 90 } // end function operator== // overloaded subscript operator for non-const DoubleSubscriptedArrays; 93 // reference return creates a modifiable lvalue 94 int &DoubleSubscriptedArray::operator()( 95 int rowsubscript, int columnsubscript ) 96 { 97 // check for subscript out-of-range error 98 if ( ( rowsubscript < 0 rowsubscript >= rowsize ) 99 ( columnsubscript < 0 columnsubscript >= columnsize ) ) 100 { 101 cerr << "\nerror: One or both subscripts out of range" << endl; 102 exit( 1 ); // terminate program; one or both subscripts out of range 103 } // end if // reference return 106 return ptr[ ( rowsubscript * columnsize ) + columnsubscript ]; 107 } // end function operator() // overloaded subscript operator for const DoubleSubscriptedArrays 110 // const reference return creates an rvalue 111 int DoubleSubscriptedArray::operator()( 112 int rowsubscript, int columnsubscript ) const 113 { 114 // check for subscript out-of-range error 115 if ( ( rowsubscript < 0 rowsubscript >= rowsize ) 116 ( columnsubscript < 0 columnsubscript >= columnsize ) ) 117 { 118 cerr << "\nerror: One or both subscripts out of range" << endl; 119 exit( 1 ); // terminate program; one or both subscripts out of range 120 } // end if // returns copy of this element 4

5 123 return ptr[ ( rowsubscript * columnsize ) + columnsubscript ]; 124 } // end function operator() // overloaded input operator for class DoubleSubscriptedArray; 127 // inputs values for entire DoubleSubscriptedArray 128 istream &operator>>( istream &input, DoubleSubscriptedArray &a ) 129 { 130 for ( int loop = 0; loop < a.rowsize * a.columnsize; loop++ ) 131 input >> a.ptr[ loop ]; return input; // enables cin >> x >> y; 134 } // end function operator>> // overloaded output operator for class DoubleSubscriptedArray 137 ostream &operator<<( ostream &output, const DoubleSubscriptedArray &a ) 138 { 139 for ( int loop = 0; loop < a.rowsize; loop++ ) 140 { 141 for ( int loop2 = 0; loop2 < a.columnsize; loop2++ ) 142 output << a.ptr[ ( loop * a.columnsize ) + loop2 ] << ' '; output << endl; 145 } // end for return output; // enables cout << x << y; 148 } // end function operator<< 1 // Exercise Solution: ex11_11.cpp 2 // DoubleSubscriptedArray class test program. 3 #include <iostream> 4 #include "DoubleSubscriptedArray.h" 5 using namespace std; 6 7 int main() 8 { 9 DoubleSubscriptedArray integers1( 2, 4 ); // seven-element array 10 DoubleSubscriptedArray integers2; // 3-by-3 array by default // print integers1 size and contents 13 cout << "Size of DoubleSubscriptedArray integers1 is " 14 << integers1.getrowsize() << " X " << integers1.getcolumnsize() 15 << "\ndoublesubscriptedarray after initialization:\n" << integers1; // print integers2 size and contents 18 cout << "\nsize of DoubleSubscriptedArray integers2 is " 5

6 19 << integers2.getrowsize() << " X " << integers2.getcolumnsize() 20 << "\ndoublesubscriptedarray after initialization:\n" << integers2; // input and print integers1 and integers2 23 cout << "\nenter 17 integers:" << endl; 24 cin >> integers1 >> integers2; cout << "\nafter input, the DoubleSubscriptedArrays contain:\n" 27 << "integers1:\n" << integers1 28 << "\nintegers2:\n" << integers2 << endl; // use overloaded inequality (!=) operator 31 cout << "Evaluating: integers1!= integers2" << endl; if ( integers1!= integers2 ) 34 cout << "integers1 and integers2 are not equal" << endl; // create DoubleSubscriptedArray integers3 using integers1 as an 37 // initializer with copy constructor; print size and contents 38 DoubleSubscriptedArray integers3( integers1 ); cout << "\nsize of DoubleSubscriptedArray integers3 is " 41 << integers3.getrowsize() << " X " << integers3.getcolumnsize() 42 << "\ndoublesubscriptedarray after initialization:\n" << integers3; // use overloaded assignment (=) operator 45 cout << "\nassigning integers2 to integers1:" << endl; 46 integers1 = integers2; // note target Array is smaller cout << "integers1:\n" << integers1 49 << "\nintegers2:\n" << integers2; // use overloaded equality (==) operator 52 cout << "\nevaluating: integers1 == integers2" << endl; if ( integers1 == integers2 ) 55 cout << "integers1 and integers2 are equal" << endl; // use overloaded subscript operator to create rvalue 58 cout << "\nintegers1( 1, 2 ) is " << integers1( 1, 2 ); // use overloaded subscript operator to create lvalue 61 cout << "\n\nassigning 1000 to integers1( 1, 2 )" << endl; 62 integers1( 1, 2 ) = 1000; 63 cout << "integers1:\n" << integers1; 64 6

7 65 // attempt to use out-of-range subscript 66 cout << "\nattempt to assign 1000 to integers1( 15, 2 )" << endl; 67 integers1( 15, 2 ) = 1000; // ERROR: out of range 68 } // end main Ex // Exercise Solution: Hugeint.h 2 // HugeInt class definition. 3 #ifndef HUGEINT_H 4 #define HUGEINT_H 5 6 #include <iostream> 7 #include <string> 8 using namespace std; 9 10 class HugeInt 11 { 12 friend ostream &operator<<( ostream &, const HugeInt & ); 13 public: 14 static const int digits = 30; // maximum digits in a HugeInt HugeInt( long = 0 ); // conversion/default constructor 17 HugeInt( const string & ); // conversion constructor // addition operator; HugeInt + HugeInt 20 HugeInt operator+( const HugeInt & ) const; // addition operator; HugeInt + int 23 HugeInt operator+( int ) const; // addition operator; 26 // HugeInt + string that represents large integer value 27 HugeInt operator+( const string & ) const; bool operator==( const HugeInt & ) const; // equality operator 30 bool operator!=( const HugeInt & ) const; // inequality operator 31 bool operator<( const HugeInt & ) const; // less than operator // less than or equal to operator 34 bool operator<=( const HugeInt & ) const; 35 bool operator>( const HugeInt & ) const; // greater than operator // greater than or equal to operator 38 bool operator>=( const HugeInt & ) const; 39 HugeInt operator-( const HugeInt & ) const; // subtraction operator 40 HugeInt operator*( const HugeInt & ) const; // multiply two HugeInts 7

8 41 HugeInt operator/( const HugeInt & ) const; // divide two HugeInts int getlength() const; 44 private: 45 short integer[ digits ]; 46 }; // end class HugeInt #endif 1 // Exercise Solution: Hugeint.cpp 2 // HugeInt member-function and friend-function definitions. 3 #include <iostream> 4 #include <cctype> // isdigit function prototype 5 #include "Hugeint.h" // HugeInt class definition 6 using namespace std; 7 8 // default constructor; conversion constructor that converts 9 // a long integer into a HugeInt object 10 HugeInt::HugeInt( long value ) 11 { 12 // initialize array to zero 13 for ( int i = 0; i < digits; i++ ) 14 integer[ i ] = 0; // place digits of argument into array 17 for ( int j = digits - 1; value!= 0 && j >= 0; j-- ) 18 { 19 integer[ j ] = value % 10; 20 value /= 10; 21 } // end for 22 } // end HugeInt default/conversion constructor // conversion constructor that converts a character string 25 // representing a large integer into a HugeInt object 26 HugeInt::HugeInt( const string &number ) 27 { 28 // initialize array to zero 29 for ( int i = 0; i < digits; i++ ) 30 integer[ i ] = 0; // place digits of argument into array 33 int length = number.size(); for ( int j = digits - length, k = 0; j < digits; j++, k++ ) 36 if ( isdigit( number[ k ] ) ) 8

9 37 integer[ j ] = number[ k ] - '0'; } // end HugeInt conversion constructor // get function calculates length of integer 42 int HugeInt::getLength() const 43 { 44 int i; for ( i = 0; i < digits; i++ ) 47 if ( integer[ i ]!= 0 ) 48 break; // break when first digit is reached return digits - i; // length is from first digit (at i) to end of array 51 } // end function getlength // addition operator; HugeInt + HugeInt 54 HugeInt HugeInt::operator+( const HugeInt &op2 ) const 55 { 56 HugeInt temp; // temporary result 57 int carry = 0; for ( int i = digits - 1; i >= 0; i-- ) 60 { 61 temp.integer[ i ] = integer[ i ] + op2.integer[ i ] + carry; // determine whether to carry a 1 64 if ( temp.integer[ i ] > 9 ) 65 { 66 temp.integer[ i ] %= 10; // reduce to carry = 1; 68 } // end if 69 else // no carry 70 carry = 0; 71 } // end for return temp; // return copy of temporary object 74 } // end function operator // addition operator; HugeInt + int 77 HugeInt HugeInt::operator+( int op2 ) const 78 { 79 // convert op2 to a HugeInt, then invoke 80 // operator+ for two HugeInt objects 81 return *this + HugeInt( op2 ); 82 } // end function operator+ 9

10 83 84 // addition operator; 85 // HugeInt + string that represents large integer value 86 HugeInt HugeInt::operator+( const string &op2 ) const 87 { 88 // convert op2 to a HugeInt, then invoke 89 // operator+ for two HugeInt objects 90 return *this + HugeInt( op2 ); 91 } // end function operator // equality operator; HugeInt == HugeInt 94 bool HugeInt::operator==( const HugeInt &op2 ) const 95 { 96 for ( int i = 0; i < digits; i++ ) // compare each element 97 if ( op2.integer[ i ]!= integer[ i ] ) 98 return false; // return false if mismatch found return true; // all elements match, return true 101 } // end function operator== // inequality operator; HugeInt!= HugeInt 104 bool HugeInt::operator!=( const HugeInt &op2 ) const 105 { 106 return!( *this == op2 ); // return opposite of == 107 } // end function operator!= // less than operator; HugeInt < HugeInt 110 bool HugeInt::operator<( const HugeInt &op2 ) const 111 { 112 for ( int i = 0; i < digits; i++ ) // compare each element 113 { 114 if ( integer[ i ] == op2.integer[ i ] ) 115 continue; // test next element 116 else if ( integer[ i ] > op2.integer[ i ] ) 117 return false; // first element larger 118 else 119 return true; // first element smaller 120 } // end for return false; // if reached this point, objects are equal 123 } // end function operator< // less than or equal operator; HugeInt <= HugeInt 126 bool HugeInt::operator<=( const HugeInt &op2 ) const 127 { 128 return!( *this > op2 ); 10

11 129 } // end function operator<= // greater than operator; HugeInt > HugeInt 132 bool HugeInt::operator>( const HugeInt &op2 ) const 133 { 134 return op2 < *this; 135 } // end function operator> // greater than or equal operator; HugeInt >= HugeInt 138 bool HugeInt::operator>=( const HugeInt &op2 ) const 139 { 140 return!( *this < op2 ); 141 } // end function operator>= // overloaded output operator 144 ostream& operator<<( ostream &output, const HugeInt &num ) 145 { 146 int i; for ( i = 0; i < HugeInt::digits && num.integer[ i ] == 0; i++ ) 149 ; // skip leading zeros if ( i == HugeInt::digits ) 152 output << 0; 153 else 154 for ( ; i < HugeInt::digits; i++ ) 155 output << num.integer[ i ]; return output; 158 } // end function operator<< // subtraction operator, subtract op2 from (*this) 161 HugeInt HugeInt::operator-( const HugeInt &op2 ) const 162 { 163 // return if first value is smaller; we are not handling negatives 164 if ( op2 > *this ) 165 { 166 cout << "Error: Tried to subtract larger value from smaller value." 167 << endl; 168 return HugeInt( "0" ); 169 } // end if HugeInt result( "0" ); // final result currently // used to determine if previous digit had 10 added to it; 174 // if true, current digit needs to be reduced by 1 11

12 175 bool minusone = false; // for each digit in both arrays, 178 // subtract digit of smaller int from digit of larger int 179 for ( int i = digits - 1; i >= 0; i-- ) 180 { 181 // find digits we will currently be subtracting 182 int topvalue = this->integer[ i ]; 183 int bottomvalue = op2.integer[ i ]; // if previous topvalue had 10 added to it; 186 // subtract one from current topvalue 187 if ( minusone ) 188 { 189 if ( topvalue == 0 ) // topvalue cannot become // set to 9 but keep minusone true for next digit 191 topvalue = 9; 192 else 193 { 194 topvalue -= 1; // subtract from top value 195 minusone = false; // minusone is handled, return to false 196 } // end else 197 } // end outer if if ( topvalue >= bottomvalue ) 200 // if topvalue larger, perform subtraction and store result 201 result.integer[ i ] = topvalue - bottomvalue; 202 else 203 { 204 topvalue += 10; // if bottomvalue larger, add 10 to topvalue 205 minusone = true; // next digit must be decreased // topvalue is now larger, perform subtraction and store result 208 result.integer[ i ] = topvalue - bottomvalue; 209 } // end else 210 } // end for return result; // return final result 213 } // end function operator // multiplication operator; multiply op2 with (*this) 216 HugeInt HugeInt::operator*( const HugeInt &op2 ) const 217 { 218 int carryover = 0; // carry value when previous digits are multiplied 219 HugeInt total( "0" ); // result currently

13 221 // find the smaller int 222 HugeInt smaller = ( *this < op2 )? *this : op2; 223 HugeInt larger = ( *this > op2 )? *this : op2; // determine index of larger's first digit; used to determine 226 // when to stop multiplying 227 int x; for ( x = 0; ( x < digits ) && ( larger.integer[ x ] == 0 ); x++ ) 230 ; int indexoffirstdigitforlarger = x; // for each digit in smaller, multiply by each digit in larger 235 for ( int i = digits; i > digits - smaller.getlength(); i-- ) 236 { 237 // currentint stores result of current digit in 238 // smaller multiplied by digits in larger 239 HugeInt currentint( "0" ); // currentintfronthandle used to keep track of 242 // index of first digit in currentint 243 int currentintfronthandle = i - 1; // multiply each digit in larger with the current digit in smaller; 246 // go backward from last digit in larger to first digit 247 for ( int j = digits; j > digits - larger.getlength(); j-- ) 248 { 249 // perform multiplication; 250 // add carryover from previous multiplications 251 int currentresult = carryover ( larger.integer[ j - 1 ] * smaller.integer[ i - 1 ] ); // if we have reached the first digit of larger 255 if ( j - 1 == indexoffirstdigitforlarger ) 256 { 257 carryover = 0; // no more carryover required // store two digits at beginning of currentint, update handle 260 currentint.integer[ currentintfronthandle ] = 261 currentresult % 10; 262 currentintfronthandle -= 1; 263 currentint.integer[ currentintfronthandle ] = 264 currentresult / 10; 265 currentintfronthandle -= 1; 266 } // end if 13

14 267 else 268 { 269 // carryover is first digit when currentresult > carryover = currentresult / 10; // store remaining digit in current result; update handle 273 currentint.integer[ currentintfronthandle ] = 274 currentresult % 10; 275 currentintfronthandle -= 1; 276 } // end else 277 } // end inner for total = total + currentint; // add current result to running total 280 } // end outer for return total; // return product 283 } // end function operator* // division operator; divide op2 by (*this) 286 HugeInt HugeInt::operator/( const HugeInt &op2 ) const 287 { 288 // use copy constructor to create remainderintegers; 289 // remainderintegers used to add digits to remainders 290 HugeInt remainderintegers( *this ); // contains portion of (*this) 293 HugeInt currentvalue( "0" ); 294 HugeInt result( "0" ); // final result, 0 for now // solution will not be longer than original value being divided 297 int maxsolutionlength = this->getlength(); // for each digit in value being divided 300 for ( int i = digits - maxsolutionlength; i < digits; i++ ) 301 { 302 // add remainder to end of current value 303 currentvalue = currentvalue * HugeInt( "10" ); 304 currentvalue.integer[ digits - 1 ] = remainderintegers.integer[ i ]; HugeInt tempresult( "0" ); // result of currentvalue divided by op if ( op2 > currentvalue ) 309 // store result of op2 / currentvalue 310 result.integer[ i ] = 0; 311 else 312 { 14

15 313 int j; // op2 / currentvalue cannot be greater than 9; 316 // use loop to determine what solution is 317 for ( j = 1; j <= 10; j++ ) 318 { 319 HugeInt tempproduct = op2 * HugeInt( j ); // if op2 * HugeInt( j ) is greater than currentvalue, 322 // then op2 / currentvalue is the value of j if ( tempproduct > currentvalue ) 324 break; 325 } // end for result.integer[ i ] = j - 1; // result of op2 / currentvalue // product used to determine next value that must be divided 330 tempresult = op2 * HugeInt( j - 1 ); 331 } // end else // subtract tempresult to get remainder used to continue division 334 currentvalue = currentvalue - tempresult; 335 } // end for return result; 338 } // end function operator/ 1 // Exercise Solution: ex11_14.cpp 2 // HugeInt test program. 3 #include <iostream> 4 #include "Hugeint.h" 5 using namespace std; 6 7 int main() 8 { 9 HugeInt n1( ); 10 HugeInt n2( ); 11 HugeInt n3( " " ); 12 HugeInt n4( "1" ); 13 HugeInt n5( " " ); 14 HugeInt n6( "7888" ); 15 HugeInt result; cout << "n1 is " << n1 << "\nn2 is " << n2 18 << "\nn3 is " << n3 << "\nn4 is " << n4 15

16 19 << "\nn5 is " << n5 << "\nn6 is " << n6 20 << "\nresult is " << result << "\n\n"; // test relational and equality operators 23 if ( n1 == n2 ) 24 cout << "n1 equals n2" << endl; if ( n1!= n2 ) 27 cout << "n1 is not equal to n2" << endl; if ( n1 < n2 ) 30 cout << "n1 is less than n2" << endl; if ( n1 <= n2 ) 33 cout << "n1 is less than or equal to n2" << endl; if ( n1 > n2 ) 36 cout << "n1 is greater than n2" << endl; if ( n1 >= n2 ) 39 cout << "n1 is greater than or equal to n2" << endl; result = n1 + n2; 42 cout << n1 << " + " << n2 << " = " << result << "\n\n"; cout << n3 << " + " << n4 << "\n= " << ( n3 + n4 ) << "\n\n"; result = n1 + 9; 47 cout << n1 << " + " << 9 << " = " << result << endl; result = n2 + "10000"; 50 cout << n2 << " + " << "10000" << " = " << result << endl; result = n5 * n6; 53 cout << n5 << " * " << n6 << " = " << result << endl; result = n5 - n6; 56 cout << n5 << " - " << n6 << " = " << result << endl; result = n5 / n6; 59 cout << n5 << " / " << n6 << " = " << result << endl; 60 } // end main 16

17 Ex // Exercise Solution: Polynomial.h 2 // Polynomial class definition. 3 #ifndef POLYNOMIAL_H 4 #define POLYNOMIAL_H 5 6 class Polynomial 7 { 8 public: 9 static const int maxterms = 100; // maximum number of terms Polynomial(); 12 Polynomial operator+( const Polynomial & ) const; // addition 13 Polynomial operator-( const Polynomial & ) const; // subtraction 14 Polynomial operator*( const Polynomial & ) const; // multiplication 15 Polynomial &operator=( const Polynomial & ); // assignment 16 Polynomial &operator+=( const Polynomial & ); 17 Polynomial &operator-=( const Polynomial & ); 18 Polynomial &operator*=( const Polynomial & ); 19 void enterterms(); 20 void printpolynomial() const; 21 int getnumberofterms() const; // user can only retrieve value 22 int gettermexponent( int ) const; 23 int gettermcoefficient( int ) const; 24 void setcoefficient( int, int ); // set coefficient of a specific term 25 ~Polynomial(); // destructor 26 private: 27 int numberofterms; 28 int exponents[ maxterms ]; // exponent array 29 int coefficients[ maxterms ]; // coefficients array 30 static void polynomialcombine( Polynomial & ); // combine common terms 31 }; // end class Polynomial #endif 1 // Exercise Solution: Polynomial.cpp 2 // Polynomial member-function definitions. 3 #include <iostream> 4 #include <iomanip> 5 #include "Polynomial.h" 6 using namespace std; 7 8 Polynomial::Polynomial() 17

18 9 { 10 for ( int t = 0; t < maxterms; t++ ) 11 { 12 coefficients[ t ] = 0; 13 exponents[ t ] = 0; 14 } // end for numberofterms = 0; 17 } // end Polynomial constructor void Polynomial::printPolynomial() const 20 { 21 int start; 22 bool zero = false; if ( coefficients[ 0 ] ) // output constants 25 { 26 cout << coefficients[ 0 ]; 27 start = 1; 28 zero = true; // at least one term exists 29 } 30 else 31 { 32 if ( coefficients[ 1 ] ) 33 { 34 cout << coefficients[ 1 ] << 'x'; // constant does not exist 35 // so output first term 36 // without a sign 37 if ( ( exponents[ 1 ]!= 0 ) && ( exponents[ 1 ]!= 1 ) ) 38 cout << '^' << exponents[ 1 ]; zero = true; // at least one term exists 41 } // end inner if start = 2; 44 } // end else // output remaining polynomial terms 47 for ( int x = start; x < maxterms; x++ ) 48 { 49 if ( coefficients[ x ]!= 0 ) 50 { 51 cout << showpos << coefficients[ x ] << noshowpos << 'x'; if ( ( exponents[ x ]!= 0 ) && ( exponents[ x ]!= 1 ) ) 54 cout << '^' << exponents[ x ]; 18

19 55 56 zero = true; // at least one term exists 57 } // end if 58 } // end for if (!zero ) // no terms exist in the polynomial 61 cout << '0'; cout << endl; 64 } // end function printpolynomial Polynomial &Polynomial::operator=( const Polynomial &r ) 67 { 68 exponents[ 0 ] = r.exponents[ 0 ]; 69 coefficients[ 0 ] = r.coefficients[ 0 ]; for ( int s = 1; s < maxterms; s++ ) 72 { 73 if ( r.exponents[ s ]!= 0 ) 74 { 75 exponents[ s ] = r.exponents[ s ]; 76 coefficients[ s ] = r.coefficients[ s ]; 77 } 78 else 79 { 80 if ( exponents[ s ] == 0 ) 81 break; exponents[ s ] = 0; 84 coefficients[ s ] = 0; 85 } // end else 86 } // end for return *this; 89 } // end function operator= Polynomial Polynomial::operator+( const Polynomial &r ) const 92 { 93 Polynomial temp; 94 bool exponentexists; 95 int s; // process element with a zero exponent 98 temp.coefficients[ 0 ] = coefficients[ 0 ] + r.coefficients[ 0 ]; // copy right arrays into temp object; s will be used to keep 19

20 101 // track of first open coefficient element 102 for ( s = 1; ( s < maxterms ) && ( r.exponents[ s ]!= 0 ); s++ ) 103 { 104 temp.coefficients[ s ] = r.coefficients[ s ]; 105 temp.exponents[ s ] = r.exponents[ s ]; 106 } // end for for ( int x = 1; x < maxterms; x++ ) 109 { 110 exponentexists = false; // assume exponent will not be found for ( int t = 1; ( t < maxterms ) && (!exponentexists ); t++ ) 113 if ( exponents[ x ] == temp.exponents[ t ] ) 114 { 115 temp.coefficients[ t ] += coefficients[ x ]; 116 exponentexists = true; // exponent found 117 } // end if // exponent was not found, insert into temp 120 if (!exponentexists ) 121 { 122 temp.exponents[ s ] = exponents[ x ]; 123 temp.coefficients[ s ] += coefficients[ x ]; 124 s++; 125 } // end if 126 } // end for return temp; 129 } // end function operator Polynomial &Polynomial::operator+=( const Polynomial &r ) 132 { 133 *this = *this + r; 134 return *this; 135 } // end function operator+= Polynomial Polynomial::operator-( const Polynomial &r ) const 138 { 139 Polynomial temp; 140 bool exponentexists; 141 int s; // process element with a zero exponent 144 temp.coefficients[ 0 ] = coefficients[ 0 ] - r.coefficients[ 0 ]; // copy left arrays into temp object; s will be used to keep 20

21 147 // track of first open coefficient element 148 for ( s = 1; ( s < maxterms ) && ( exponents[ s ]!= 0 ); s++ ) 149 { 150 temp.coefficients[ s ] = coefficients[ s ]; 151 temp.exponents[ s ] = exponents[ s ]; 152 } // end for for ( int x = 1; x < maxterms; x++ ) 155 { 156 exponentexists = false; // assume exponent will not be found for ( int t = 1; ( t < maxterms ) && (!exponentexists ); t++ ) if ( r.exponents[ x ] == temp.exponents[ t ] ) 161 { 162 temp.coefficients[ t ] -= r.coefficients[ x ]; 163 exponentexists = true; // exponent found 164 } // end if // exponent was not found, insert into temp 167 if (!exponentexists ) 168 { 169 temp.exponents[ s ] = r.exponents[ x ]; 170 temp.coefficients[ s ] -= r.coefficients[ x ]; 171 s++; 172 } // end if 173 } // end for return temp; 176 } // end function operator Polynomial &Polynomial::operator-=( const Polynomial &r ) 179 { 180 *this = *this - r; 181 return *this; 182 } // end function operator-= Polynomial Polynomial::operator*( const Polynomial &r ) const 185 { 186 Polynomial temp; 187 int s = 1; // subscript location for temp coefficient and exponent for ( int x = 0; ( x < maxterms ) && 190 ( x == 0 coefficients[ x ]!= 0 ); x++ ) for ( int y = 0; ( y < maxterms ) && 21

22 193 ( y == 0 r.coefficients[ y ]!= 0 ); y++ ) if ( coefficients[ x ] * r.coefficients[ y ] ) if ( ( exponents[ x ] == 0 ) && ( r.exponents[ y ] == 0 ) ) 198 temp.coefficients[ 0 ] += 199 coefficients[ x ] * r.coefficients[ y ]; 200 else 201 { 202 temp.coefficients[ s ] = 203 coefficients[ x ] * r.coefficients[ y ]; 204 temp.exponents[ s ] = exponents[ x ] + r.exponents[ y ]; 205 s++; 206 } // end else polynomialcombine( temp ); // combine common terms 209 return temp; 210 } // end function operator* void Polynomial::polynomialCombine( Polynomial &w ) 213 { 214 Polynomial temp = w; // zero out elements of w 217 for ( int x = 0; x < maxterms; x++ ) 218 { 219 w.coefficients[ x ] = 0; 220 w.exponents[ x ] = 0; 221 } // end for for ( int x = 1; x < maxterms; x++ ) 224 { 225 for ( int y = x + 1; y < maxterms; y++ ) 226 if ( temp.exponents[ x ] == temp.exponents[ y ] ) 227 { 228 temp.coefficients[ x ] += temp.coefficients[ y ]; 229 temp.exponents[ y ] = 0; 230 temp.coefficients[ y ] = 0; 231 } // end if 232 } // end outer for w = temp; 235 } // end function polynomialcombine Polynomial &Polynomial::operator*=( const Polynomial &r ) 238 { 22

23 239 *this = *this * r; 240 return *this; 241 } // end function operator*= void Polynomial::enterTerms() 244 { 245 bool found = false; 246 int c, e, term; cout << "\nenter number of polynomial terms: "; 249 cin >> numberofterms; for ( int n = 0; n < maxterms && n < numberofterms; n++ ) 252 { 253 cout << "\nenter coefficient: "; 254 cin >> c; 255 cout << "Enter exponent: "; 256 cin >> e; if ( c!= 0 ) 259 { 260 // exponents of zero are forced into first element 261 if ( e == 0 ) 262 { 263 coefficients[ 0 ] += c; 264 continue; 265 } // end if for ( term = 1; ( term < maxterms ) && 268 ( coefficients[ term ]!= 0 ); term++ ) if ( e == exponents[ term ] ) 271 { 272 coefficients[ term ] += c; 273 exponents[ term ] = e; 274 found = true; // existing exponent updated 275 } // end if if (!found ) // add term 278 { 279 coefficients[ term ] += c; 280 exponents[ term ] = e; 281 } // end if 282 } // end outer if 283 } // end outer for 284 } // end function endterms 23

24 int Polynomial::getNumberOfTerms() const 287 { 288 return numberofterms; 289 } // end function getnumberofterms int Polynomial::getTermExponent( int term ) const 292 { 293 return exponents[ term ]; 294 } // end function gettermexponent int Polynomial::getTermCoefficient( int term ) const 297 { 298 return coefficients[ term ]; 299 } // end function gettermscoefficient void Polynomial::setCoefficient( int term, int coefficient ) 302 { 303 if ( coefficients[ term ] == 0 ) // no term at this location 304 cout << "No term at this location, cannot set term." << endl; 305 else // otherwise, set term 306 coefficients[ term ] = coefficient; 307 } // end function setterm // destructor 310 Polynomial::~Polynomial() 311 { 312 // empty destructor 313 } // end destructor 1 // Exercise Solution: ex11_17.cpp 2 // Polynomial test program. 3 #include <iostream> 4 #include "Polynomial.h" 5 using namespace std; 6 7 int main() 8 { 9 Polynomial a, b, c, t; a.enterterms(); 12 b.enterterms(); 13 t = a; // save the value of a 14 cout << "First polynomial is:\n"; 15 a.printpolynomial(); 24

25 16 cout << "Second polynomial is:\n"; 17 b.printpolynomial(); 18 cout << "\nadding the polynomials yields:\n"; 19 c = a + b; 20 c.printpolynomial(); 21 cout << "\n+= the polynomials yields:\n"; 22 a += b; 23 a.printpolynomial(); 24 cout << "\nsubtracting the polynomials yields:\n"; 25 a = t; // reset a to original value 26 c = a - b; 27 c.printpolynomial(); 28 cout << "\n-= the polynomials yields:\n"; 29 a -= b; 30 a.printpolynomial(); 31 cout << "\nmultiplying the polynomials yields:\n"; 32 a = t; // reset a to original value 33 c = a * b; 34 c.printpolynomial(); 35 cout << "\n*= the polynomials yields:\n"; 36 a *= b; 37 a.printpolynomial(); 38 cout << endl; 39 } // end main 25