Design the class linetype to implement a line so that the class lineType: 1. Overloads the stream insertion operator, $ >$, for easy intput. (The line $a x+b y=c$ is input as $(a, b, c)$. 3. Overloads the assignment operator to copy a line into another line. 4. Overloads the unary operator $+$, as a member function, so that it returns true if a line is vertical; false otherwise. 5. Overloads the unary operator -, as a member function, so that it returns true if a line is horizontal; false otherwise. 6. Overloads the operator $==$, as a member function, so that it returns true if two lines are equal; false otherwise. 7. Overloads the operator $| |$, as a member function, so that it returns true if two lines are parallel; false otherwise. 8. Overloads the operator $\& \&$, as a member function, so that it returns true if two lines are perpendicular; false otherwise. Write a program to test your class.

Setup: #include using namespace std; class lineType{ public: bool vertical() const; void slope(); bool equal(lineType) const; bool parallel(lineType) const; bool perpendicular(lineType) const; void intersection(lineType); void printSlope() const; void printIntersection() const; lineType(float = 0.0, float = 0.0, float = 0.0); friend ostream& operator > (istream& isObject, lineType& cObject); const lineType& operator = (const lineType&); bool operator + (); bool operator - (); bool operator == (const lineType& b); bool operator || (const lineType& line); bool operator && (const lineType& line); private: float a; float b; float c; float sl; float xi; float yi; };

Design the class linetype to implement a line so that the cl

Design the class linetype to implement a line so that the class lineType:

Overloads the stream insertion operator, $<<$ , for easy output.
Overloads the stream extraction operator, $>>$ , for easy intput. (The line $a x+b y=c$ is input as $(a, b, c)$ .
Overloads the assignment operator to copy a line into another line.
Overloads the unary operator $+$ , as a member function, so that it returns true if a line is vertical; false otherwise.
Overloads the unary operator -, as a member function, so that it returns true if a line is horizontal; false otherwise.
Overloads the operator $==$ , as a member function, so that it returns true if two lines are equal; false otherwise.
Overloads the operator $| |$ , as a member function, so that it returns true if two lines are parallel; false otherwise.
Overloads the operator $\& \&$ , as a member function, so that it returns true if two lines are perpendicular; false otherwise. Write a program to test your class.

friend ostream& operator << (ostream& osObject, const lineType& cObject); friend istream& operator >> (istream& isObject, lineType& cObject); const lineType& operator = (const lineType&); bool operator + (); bool operator - (); bool operator == (const lineType& b); bool operator || (const lineType& line); bool operator && (const lineType& line); private: float a; float b; float c; float sl; float xi; float yi;

(HugeInt Class) A machine with 32-bit integers can represent integers in the range of approximately –2 billion to +2 billion. This fixed-size restriction is rarely troublesome, but there are applications in which we’d like to be able to use a much wider range of integers. This is what C++ was built to do, namely, create powerful new data types. Consider class HugeInt of previous figures. Study the class carefully, then answer the following:

a) Describe precisely how it operates.
b) What restrictions does the class have?
c) Overload the * multiplication operator.
d) Overload the / division operator.
e) Overload all the relational and equality operators. [Note: We do not show an assignment operator or copy constructor for class HugeInteger, because the assignment operator and copy constructor provided by the compiler are capable of copying the entire array data member properly.]

1 // Fig: 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
15
16 HugeInt( long = 0 ); // conversion/default constructor
17 HugeInt( const string & ); // conversion constructor
18
19 // addition operator; HugeInt + HugeInt
20 HugeInt operator+( const HugeInt & ) const;
21
22 // addition operator; HugeInt + int
23 HugeInt operator+( int ) const; 
24
25 // addition operator; 
26 // HugeInt + string that represents large integer value
27 HugeInt operator+( const string & ) const; 
28 private:
29 short integer[ digits ];
30 }; // end class HugetInt
31
32 #endif

1 // Fig: Hugeint.cpp 
2 // HugeInt member-function and friend-function definitions.
3 #include <cctype> // isdigit function prototype
4 #include "Hugeint.h" // HugeInt class definition
5 using namespace std;
6
7 // default constructor; conversion constructor that converts
8 // a long integer into a HugeInt object
9 HugeInt::HugeInt( long value )
10 {
11 // initialize array to zero
12 for ( int i = 0; i < digits; i++ )
13 integer[ i ] = 0; 
14
15 // place digits of argument into array 
16 for ( int j = digits - 1; value != 0 && j >= 0; j-- )
17 {
18 integer[ j ] = value % 10;
19 value /= 10;
20 } // end for
21 } // end HugeInt default/conversion constructor
22
23 // conversion constructor that converts a character string 
24 // representing a large integer into a HugeInt object
25 HugeInt::HugeInt( const string &number )
26 {
27 // initialize array to zero
28 for ( int i = 0; i < digits; i++ )
29 integer[ i ] = 0;
30
31 // place digits of argument into array
32 int length = number.size();
33
34 for ( int j = digits - length, k = 0; j < digits; j++, k++ )
35 if ( isdigit( number[ k ] ) ) // ensure that character is a digit
36 integer[ j ] = number[ k ] - '0';
37 } // end HugeInt conversion constructor
38
39 // addition operator; HugeInt + HugeInt
40 HugeInt HugeInt::operator+( const HugeInt &op2 ) const
41 {
42 HugeInt temp; // temporary result
43 int carry = 0;
44
45 for ( int i = digits - 1; i >= 0; i-- )
46 {
47 temp.integer[ i ] = integer[ i ] + op2.integer[ i ] + carry;
48
49 // determine whether to carry a 1
50 if ( temp.integer[ i ] > 9 )
51 {
52 temp.integer[ i ] %= 10; // reduce to 0-9
53 carry = 1;
54 } // end if
55 else // no carry 
56 carry = 0;
57 } // end for
58
59 return temp; // return copy of temporary object
60 } // end function operator+
61
62 // addition operator; HugeInt + int
63 HugeInt HugeInt::operator+( int op2 ) const
64 {
65 // convert op2 to a HugeInt, then invoke
66 // operator+ for two HugeInt objects
67 return *this + HugeInt( op2 ); 
68 } // end function operator+
69
70 // addition operator;
71 // HugeInt + string that represents large integer value
72 HugeInt HugeInt::operator+( const string &op2 ) const
73 {
74 // convert op2 to a HugeInt, then invoke 
75 // operator+ for two HugeInt objects
76 return *this + HugeInt( op2 ); 
77 } // end operator+
78
79 // overloaded output operator
80 ostream& operator<<( ostream &output, const HugeInt &num )
81 {
82 int i;
83
84 for ( i = 0; ( num.integer[ i ] == 0 ) && ( i <= HugeInt::digits ); i++ )
85 ; // skip leading zeros
86
87 if ( i == HugeInt::digits )
88 output << 0;
89 else
90 for ( ; i < HugeInt::digits; i++ )
91 output << num.integer[ i ];
92
93 return output;
94 } // end function operator<<

1 // Fig: fig.cpp
2 // HugeInt test program.
3 #include <iostream>
4 #include "Hugeint.h"
5 using namespace std;
6
7 int main()
8 {
9 HugeInt n1( 7654321 );
10 HugeInt n2( 7891234 );
11 HugeInt n3( "99999999999999999999999999999" );
12 HugeInt n4( "1" );
13 HugeInt n5;
14
15 cout << "n1 is " << n1 << "\nn2 is " << n2
16 << "\nn3 is " << n3 << "\nn4 is " << n4
17 << "\nn5 is " << n5 << "\n\n";
18
19 n5 = n1 + n2;
20 cout << n1 << " + " << n2 << " = " << n5 << "\n\n";
21
22 cout << n3 << " + " << n4 << "\n= " << ( n3 + n4 ) << "\n\n";
23
24 n5 = n1 + 9;
25 cout << n1 << " + " << 9 << " = " << n5 << "\n\n";
26
27 n5 = n2 + "10000";
28 cout << n2 << " + " << "10000" << " = " << n5 << endl;
29 } // end main

n1 is 7654321
n2 is 7891234
n3 is 99999999999999999999999999999
n4 is 1
n5 is 0
7654321 + 7891234 = 15545555
99999999999999999999999999999 + 1
= 100000000000000000000000000000
7654321 + 9 = 7654330
7891234 + 10000 = 7901234
n1 is 7654321
n2 is 7891234
n3 is 99999999999999999999999999999
n4 is 1
n5 is 0
7654321 + 7891234 = 15545555
99999999999999999999999999999 + 1
= 100000000000000000000000000000
7654321 + 9 = 7654330
7891234 + 10000 = 7901234

1 // Fig: 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 15 16 HugeInt( long = 0 ); // conversion/default constructor 17 HugeInt( const string & ); // conversion constructor 18 19 // addition operator; HugeInt + HugeInt 20 HugeInt operator+( const HugeInt & ) const; 21 22 // addition operator; HugeInt + int 23 HugeInt operator+( int ) const; 24 25 // addition operator; 26 // HugeInt + string that represents large integer value 27 HugeInt operator+( const string & ) const; 28 private: 29 short integer[ digits ]; 30 }; // end class HugetInt 31 32 #endif

1 // Fig: Hugeint.cpp 2 // HugeInt member-function and friend-function definitions. 3 #include <cctype> // isdigit function prototype 4 #include "Hugeint.h" // HugeInt class definition 5 using namespace std; 6 7 // default constructor; conversion constructor that converts 8 // a long integer into a HugeInt object 9 HugeInt::HugeInt( long value ) 10 { 11 // initialize array to zero 12 for ( int i = 0; i < digits; i++ ) 13 integer[ i ] = 0; 14 15 // place digits of argument into array 16 for ( int j = digits - 1; value != 0 && j >= 0; j-- ) 17 { 18 integer[ j ] = value % 10; 19 value /= 10; 20 } // end for 21 } // end HugeInt default/conversion constructor 22 23 // conversion constructor that converts a character string 24 // representing a large integer into a HugeInt object 25 HugeInt::HugeInt( const string &number ) 26 { 27 // initialize array to zero 28 for ( int i = 0; i < digits; i++ ) 29 integer[ i ] = 0; 30 31 // place digits of argument into array 32 int length = number.size(); 33 34 for ( int j = digits - length, k = 0; j < digits; j++, k++ ) 35 if ( isdigit( number[ k ] ) ) // ensure that character is a digit 36 integer[ j ] = number[ k ] - '0'; 37 } // end HugeInt conversion constructor 38 39 // addition operator; HugeInt + HugeInt 40 HugeInt HugeInt::operator+( const HugeInt &op2 ) const 41 { 42 HugeInt temp; // temporary result 43 int carry = 0; 44 45 for ( int i = digits - 1; i >= 0; i-- ) 46 { 47 temp.integer[ i ] = integer[ i ] + op2.integer[ i ] + carry; 48 49 // determine whether to carry a 1 50 if ( temp.integer[ i ] > 9 ) 51 { 52 temp.integer[ i ] %= 10; // reduce to 0-9 53 carry = 1; 54 } // end if 55 else // no carry 56 carry = 0; 57 } // end for 58 59 return temp; // return copy of temporary object 60 } // end function operator+ 61 62 // addition operator; HugeInt + int 63 HugeInt HugeInt::operator+( int op2 ) const 64 { 65 // convert op2 to a HugeInt, then invoke 66 // operator+ for two HugeInt objects 67 return *this + HugeInt( op2 ); 68 } // end function operator+ 69 70 // addition operator; 71 // HugeInt + string that represents large integer value 72 HugeInt HugeInt::operator+( const string &op2 ) const 73 { 74 // convert op2 to a HugeInt, then invoke 75 // operator+ for two HugeInt objects 76 return *this + HugeInt( op2 ); 77 } // end operator+ 78 79 // overloaded output operator 80 ostream& operator<<( ostream &output, const HugeInt &num ) 81 { 82 int i; 83 84 for ( i = 0; ( num.integer[ i ] == 0 ) && ( i <= HugeInt::digits ); i++ ) 85 ; // skip leading zeros 86 87 if ( i == HugeInt::digits ) 88 output << 0; 89 else 90 for ( ; i < HugeInt::digits; i++ ) 91 output << num.integer[ i ]; 92 93 return output; 94 } // end function operator<<

1 // Fig: fig.cpp 2 // HugeInt test program. 3 #include <iostream> 4 #include "Hugeint.h" 5 using namespace std; 6 7 int main() 8 { 9 HugeInt n1( 7654321 ); 10 HugeInt n2( 7891234 ); 11 HugeInt n3( "99999999999999999999999999999" ); 12 HugeInt n4( "1" ); 13 HugeInt n5; 14 15 cout << "n1 is " << n1 << "\nn2 is " << n2 16 << "\nn3 is " << n3 << "\nn4 is " << n4 17 << "\nn5 is " << n5 << "\n\n"; 18 19 n5 = n1 + n2; 20 cout << n1 << " + " << n2 << " = " << n5 << "\n\n"; 21 22 cout << n3 << " + " << n4 << "\n= " << ( n3 + n4 ) << "\n\n"; 23 24 n5 = n1 + 9; 25 cout << n1 << " + " << 9 << " = " << n5 << "\n\n"; 26 27 n5 = n2 + "10000"; 28 cout << n2 << " + " << "10000" << " = " << n5 << endl; 29 } // end main

n1 is 7654321 n2 is 7891234 n3 is 99999999999999999999999999999 n4 is 1 n5 is 0 7654321 + 7891234 = 15545555 99999999999999999999999999999 + 1 = 100000000000000000000000000000 7654321 + 9 = 7654330 7891234 + 10000 = 7901234 n1 is 7654321 n2 is 7891234 n3 is 99999999999999999999999999999 n4 is 1 n5 is 0 7654321 + 7891234 = 15545555 99999999999999999999999999999 + 1 = 100000000000000000000000000000 7654321 + 9 = 7654330 7891234 + 10000 = 7901234

Related questions with answers

Create an account to view solutions

Create an account to view solutions

More related questions