18-1 computing fundamentals with c++ object-oriented programming and design, 2nd edition rick mercer...
TRANSCRIPT
18-1
Computing Fundamentals with C++Computing Fundamentals with C++Object-Oriented Programming and Design, 2nd EditionObject-Oriented Programming and Design, 2nd Edition
Rick MercerRick Mercer
Franklin, Beedle & Associates, 1999Franklin, Beedle & Associates, 1999
ISBN 1-887902-36-8ISBN 1-887902-36-8
Presentation Copyright 1999, Franklin, Beedle & Associates Presentation Copyright 1999, Franklin, Beedle & Associates Students who purchase and instructors who adopt Students who purchase and instructors who adopt Computing Fundamentals with C++, Computing Fundamentals with C++, Object-Oriented Programming and Design Object-Oriented Programming and Design by Rick Mercer are welcome to use this by Rick Mercer are welcome to use this
presentation as long as this copyright notice remains intact.presentation as long as this copyright notice remains intact.
18-2Chapter 18Chapter 18Operator OverloadingOperator Overloading
Chapter ObjectivesChapter Objectives overload != and < for any state object you want overload != and < for any state object you want
contained in a standard container contained in a standard container vector listvector list
perform complex arithmeticperform complex arithmetic overload << and >> so you can output or input any overload << and >> so you can output or input any
new class of objects that you developnew class of objects that you develop
18-3 C++ Operator OverloadingC++ Operator Overloading
Built-in types (Built-in types (int doubleint double) define ) define operators operators < == != > <= >= + - / < == != > <= >= + - /
Operator overloading: operators have Operator overloading: operators have different meanings for different operands:different meanings for different operands:
ExpressionExpression 2 + 5 2 + 5 "2" + "5" "2" + "5" 2 / 52 / 52.0 / 5.0 2.0 / 5.0
Evaluates to7
"25"0
0.4
18-4 Syntactic sugarSyntactic sugar
Operator overloading provides easier to read Operator overloading provides easier to read code: code:
Employee e1, e2;Employee e1, e2; if(e1.lessThan(e2)) if(e1.lessThan(e2)) // no operator overloading needed to do this// no operator overloading needed to do this
oror
if(e1 < e2) if(e1 < e2) // operator overloading for < must have// operator overloading for < must have // been done in class Employee// been done in class Employee
18-5 Some standard classes doSome standard classes do
Overloaded operators allow your own Overloaded operators allow your own classes to "look like" the built-in typesclasses to "look like" the built-in types
Some Some standardstandard C++ classes overload some C++ classes overload some operators operators string and complex for example string and complex for example
string s1, s2;string s1, s2; cin >> s1 >> s2;cin >> s1 >> s2;if(s1 < s2)if(s1 < s2)
s1 += s2;s1 += s2;else else
s2 = s1 + s2; s2 = s1 + s2; // perform s2 += s1;// perform s2 += s1;cout << s2;cout << s2;
18-6 Our own classes couldOur own classes could
But what about programmer defined But what about programmer defined classes such as classes such as CDCD, , bankAccountbankAccount, and , and DateDate?? Wouldn't it be nice if you could overload? Wouldn't it be nice if you could overload?
see Datesee Date Do you need to?Do you need to?
Yes, if you want to use the STLYes, if you want to use the STL
18-7 Date overloads Date overloads -- and and ++
Consider adding or subtracting Date objectsConsider adding or subtracting Date objects const Date today; const Date today; // Default is today's date// Default is today's date Date graduationDay(5, 14, 1999);Date graduationDay(5, 14, 1999); int collegeDaysLeft = graduationDay - today;int collegeDaysLeft = graduationDay - today;
Date warrantyExpires; Date warrantyExpires; warrantyExpires = today + 90;warrantyExpires = today + 90;
nicenice Now consider using the STL Now consider using the STL listlist container container
18-8 Review: The STL Review: The STL listlist class class
A list object A list object a container class like vector a container class like vector
manages a collection of homogenous objectsmanages a collection of homogenous objects is sequenced--there is a first, second,...,lastis sequenced--there is a first, second,...,last can add objects at the beginning or at the end can add objects at the beginning or at the end
of the list with push_front and push_backof the list with push_front and push_back always knows how big it isalways knows how big it is is generic because it may be declared to store is generic because it may be declared to store
a collection of a collection of anyany class of objects class of objects has useful operations: find, remove, and sorthas useful operations: find, remove, and sort
18-9 Construct, Construct, push_backpush_back, , size size
Construct three list objects:Construct three list objects: list <int> tests; list <int> tests; // size is 0// size is 0 list <double> GPAs; list <double> GPAs; list <string> nameslist <string> names; ;
Copy objects into the list with push_back:Copy objects into the list with push_back: tests.tests.push_backpush_back(95); (95); GPAs.push_back(3.67); GPAs.push_back(3.67);
names.push_back("Chris");names.push_back("Chris"); Access the number of objects with size:Access the number of objects with size: cout << tests.cout << tests.sizesize() << endl;() << endl; cout << GPAs.size() << endl;cout << GPAs.size() << endl;
cout << names.size() << endl;cout << names.size() << endl;
18-10 Can we store objects we designed?Can we store objects we designed?
The STL list contains int, double, and stringThe STL list contains int, double, and string What about our own objects?What about our own objects?
bankAccount one("Hal", 111.11);bankAccount one("Hal", 111.11); bankAccount two("Sue", 222.22);bankAccount two("Sue", 222.22); bankAccount tre("Deb", 333.33);bankAccount tre("Deb", 333.33); list <bankAccount> acctList;list <bankAccount> acctList; acctList.push_back(one);acctList.push_back(one); acctList.push_back(two);acctList.push_back(two); acctList.push_back(tre);acctList.push_back(tre); acctList.push_back(bankAccount("Four", 4.44));acctList.push_back(bankAccount("Four", 4.44));
18-11 STL element requirementsSTL element requirements
The STL containers (list, vector, map) require The STL containers (list, vector, map) require the contained elements to havethe contained elements to have a way to copy elementsa way to copy elements
the container elements are copies of the objects insertedthe container elements are copies of the objects inserted could use the default = operatorcould use the default = operator
a way to compare elementsa way to compare elements could use the relational operators could use the relational operators
< == > != <= >= < == > != <= >=
18-12 STL needs all relational STL needs all relational operators definedoperators defined
Any STL container can be sorted when the Any STL container can be sorted when the elements understand less than elements understand less than <<
acctList.sort(); acctList.sort(); // overload < to sort// overload < to sort
Any STL container can be searched when the Any STL container can be searched when the elements understand equal elements understand equal ====
list <bankAccount>::iterator i; list <bankAccount>::iterator i; i = find(acctList.begin(),i = find(acctList.begin(), acctList.end(),acctList.end(), bankAccount("Sue", 0.00));bankAccount("Sue", 0.00));
Other operations require other operators, so Other operations require other operators, so also overload !=, <=, >=, and >also overload !=, <=, >=, and >
18-13 Operator functionsOperator functions
Operators functions have a different syntaxOperators functions have a different syntax Some are free functionsSome are free functions
today < tomorrow today < tomorrow // operator < (Date,Date)// operator < (Date,Date)
Some are member functions Some are member functions d += 30; d += 30; // d.operator += (int)// d.operator += (int)
Both need access to private data either Both need access to private data either directly or through an accessing functiondirectly or through an accessing function
Here is a Here is a << free function for bankAccount free function for bankAccount it will use accessing functions to get datait will use accessing functions to get data
18-14 The header file The header file bankAccount.hbankAccount.h
class bankAccount {class bankAccount {public:public: // constructors, modifiers, and this accessor// constructors, modifiers, and this accessor string name();string name();private: private: // data members and functions// data members and functions};};
//--auxiliary free functions//--auxiliary free functionsbool operator < ( const bankAccount& left, bool operator < ( const bankAccount& left, const bankAccount& right );const bankAccount& right );bool operator == ( const bankAccount& left,bool operator == ( const bankAccount& left, const bankAccount& right );const bankAccount& right );
18-15What does < mean?What does < mean? Answer: anything you wantAnswer: anything you want
The The << and and ==== operators are overloaded for operators are overloaded for bankAccount using this general form:bankAccount using this general form:
bool operatorbool operator an-operator an-operator
( const( const classclass&& left left, const, const classclass&& right right ););
We can give any meaning to less than We can give any meaning to less than << decision: a < b is true when left's name decision: a < b is true when left's name
alphabetically precedes right's namealphabetically precedes right's name
18-16 Visualize < betweenVisualize < between the parameters the parameters
// from the file baccount.cpp// from the file baccount.cppbool operator bool operator << (const bankAccount& left, (const bankAccount& left, const bankAccount& right) const bankAccount& right) { { return left.name() return left.name() << right.name(); right.name(); }}
// From a test driver// From a test driverint main() int main() { { bankAccount b1("Bob", 222.00);bankAccount b1("Bob", 222.00); bankAccount b2("Carla", 111.00);bankAccount b2("Carla", 111.00); if(b1 if(b1 << b2) b2) // ...// ...
18-17Completing the relational Completing the relational operatorsoperators// from the file baccount.cpp// from the file baccount.cpp
bool operator == (const bankAccount& left,bool operator == (const bankAccount& left, const bankAccount& right) const bankAccount& right) { { return left.name() == right.name(); return left.name() == right.name(); }}
bool operator!= (const bankAccount& lhs,bool operator!= (const bankAccount& lhs, const bankAccount& rhs) const bankAccount& rhs) {{ return lhs.name() != rhs.name(); return lhs.name() != rhs.name(); }}
18-18 Complete all 6 for each classComplete all 6 for each class
// from the file baccount.cpp// from the file baccount.cppbool operator > (const bankAccount& lhs, bool operator > (const bankAccount& lhs, const bankAccount& rhs)const bankAccount& rhs){{ return lhs.name() > rhs.name(); return lhs.name() > rhs.name(); }}
bool operator <= (const bankAccount& lhs, bool operator <= (const bankAccount& lhs, const bankAccount& rhs) const bankAccount& rhs) { { return lhs.name() <= rhs.name(); return lhs.name() <= rhs.name(); }}
bool operator >= (const bankAccount& lhs, bool operator >= (const bankAccount& lhs, const bankAccount& rhs) const bankAccount& rhs) { { return lhs.name() >= rhs.name(); return lhs.name() >= rhs.name(); }}
18-19 Summing UpSumming Up
Operator overloading allows new classes to look Operator overloading allows new classes to look more like built-in types more like built-in types don't go crazydon't go crazy
C++ operator overloading is sometimes nice, C++ operator overloading is sometimes nice, sometimes necessarysometimes necessary
Operator functions have a different syntaxOperator functions have a different syntax The STL requires all six relational operators The STL requires all six relational operators There is a shortcut described in the standardThere is a shortcut described in the standard
If you define If you define << and and ==== the compiler will define the rest the compiler will define the rest for you for you
18-20 Coming UpComing Up
Overloading input and output operatorsOverloading input and output operators Friend functions for efficiencyFriend functions for efficiency Member operator functions Member operator functions +=+=
18-21 18.2 Using Friend Functions18.2 Using Friend Functions
The previous member functions call accessor The previous member functions call accessor methods to get the namesmethods to get the names
these two function calls can slow down programsthese two function calls can slow down programs consider sorting a large list of objects, for consider sorting a large list of objects, for
example example each comparison requires 2 function callseach comparison requires 2 function calls
it would be better to access the data members it would be better to access the data members directlydirectly but the data members are privatebut the data members are private
C++ workaround: friend functionsC++ workaround: friend functions
18-22 friend functionsfriend functions
functions can be declared inside a class with functions can be declared inside a class with the friend tagthe friend tag
this gives the function access to private data this gives the function access to private data membersmembers
Consider this modification Consider this modification
18-23 Not a member function, but Not a member function, but rather a friend functionrather a friend function
class bankAccount {class bankAccount {public:public: //...//... double balance() const;double balance() const; string name() const;string name() const;
//--friend operator functions//--friend operator functions friendfriend bool operator == (const bankAccount& left, bool operator == (const bankAccount& left, const bankAccount& right);const bankAccount& right); friendfriend bool operator < (const bankAccount& left, bool operator < (const bankAccount& left, const bankAccount& right);const bankAccount& right); //...//...};};
18-24 Implementing friend functionsImplementing friend functions
Friend functions are free functions Friend functions are free functions They have access to the private data fields of the class They have access to the private data fields of the class
where they were declared where they were declared bool operator == (const bankAccount& left, bool operator == (const bankAccount& left, const bankAccount& right)const bankAccount& right) { { // Reference data members directly// Reference data members directly return left.my_name == right.my_name; return left.my_name == right.my_name; } }
bool operator < (const bankAccount& left, bool operator < (const bankAccount& left, const bankAccount& right)const bankAccount& right) { { // Avoid function-call overhead // Avoid function-call overhead return left.my_name < right.my_name; return left.my_name < right.my_name; }}
18-2518.3 Overloading = for Classes 18.3 Overloading = for Classes with Pointer Data Memberswith Pointer Data Members
C++ overrides the = operator for vectorsC++ overrides the = operator for vectors So if a collection class like bag is assigned to So if a collection class like bag is assigned to
another, all vector elements are actually copied from another, all vector elements are actually copied from one to the otherone to the other
// The bag class with a vector data member// The bag class with a vector data member // obtained with a typedef and #include "bag"// obtained with a typedef and #include "bag" bag b1;bag b1; bag b2;bag b2; for(int j = 0; j < 6; j++)for(int j = 0; j < 6; j++) b1.add(j);b1.add(j); b2 = b1;b2 = b1; // b2 is exactly like b1 because vector overloads =// b2 is exactly like b1 because vector overloads =
18-26 = with pointers = with pointers
Since the generic class has a pointer, the same Since the generic class has a pointer, the same assignment does not work.assignment does not work.
So if a collection class like bag is assigned to another, So if a collection class like bag is assigned to another, only the pointer is copied only the pointer is copied shallow copyshallow copy
// The bag class with a pointer data member// The bag class with a pointer data member // obtained with #include "genbag"// obtained with #include "genbag" bag b1;bag b1; bag b2;bag b2; for(int j = 0; j < 6; j++)for(int j = 0; j < 6; j++) b1.add(j);b1.add(j); b2 = b1;b2 = b1; // Only the pointer gets copied and the program // Only the pointer gets copied and the program // could terminate prematurely later on. // could terminate prematurely later on.
18-27 Overloading = for vectorOverloading = for vector
The bag class should overload =The bag class should overload = The operator = function must copy the The operator = function must copy the
individual objects from one bag to the otherindividual objects from one bag to the other use a for loopuse a for loop
For example, the vector class that comes with For example, the vector class that comes with this book does thatthis book does that
see next slidesee next slide
18-28 vector operator =vector operator =
// operator = is defined inside the vector class definition// operator = is defined inside the vector class definitionvector& operator = (const vector<VectorElementType>& right)vector& operator = (const vector<VectorElementType>& right){ { if( this != &right ) if( this != &right ) // Skip deleting when aVec == aVec// Skip deleting when aVec == aVec { { // Deallocate unneeded memory (x is a pointer)// Deallocate unneeded memory (x is a pointer) delete [] x;delete [] x; // Copy the capacity data member// Copy the capacity data member this->my_capacity = right.my_capacity;this->my_capacity = right.my_capacity; // Allocate precisely the correct amount of memory// Allocate precisely the correct amount of memory this->x = new VectorElementType [this->my_capacity]; this->x = new VectorElementType [this->my_capacity]; // Copy the individual items from the right to the left// Copy the individual items from the right to the left for(int j = 0; j < this->my_capacity; j++)for(int j = 0; j < this->my_capacity; j++) {{ this->x[j] = right.x[j];this->x[j] = right.x[j]; }} }} return *this;return *this;}}
18-29 How it worksHow it works
First check to make sure you are not assigning First check to make sure you are not assigning the vector to itselfthe vector to itself
this expression is true if the address of the object to this expression is true if the address of the object to the left of = (this) is the same address as the object to the left of = (this) is the same address as the object to the right &rightthe right &right
if( this != &right ) if( this != &right ) // Skip deleting when aVec == aVec// Skip deleting when aVec == aVec
Don't do it. Otherwise the object gets deleted withDon't do it. Otherwise the object gets deleted with delete [] x;delete [] x;
Then copy the value of capacityThen copy the value of capacity Then use a for loop to copy every element Then use a for loop to copy every element
18-30 String operator =String operator =
The vector = function finally returns the The vector = function finally returns the address of new vector object address of new vector object vector&vector&
The string operator = function uses the same The string operator = function uses the same algorithmalgorithm
instead of a for loop, string uses the strcpy instead of a for loop, string uses the strcpy function.function.
see next slidesee next slide
18-31 String operator =String operator =
string& string::operator = (const string& right)string& string::operator = (const string& right){{ if (this != (&right) )if (this != (&right) ) { { delete [] my_chars; delete [] my_chars; my_len = right.my_len;my_len = right.my_len; my_chars = new char[my_len + 1];my_chars = new char[my_len + 1]; strcpy(my_chars, right.my_chars);strcpy(my_chars, right.my_chars); }} return *this;return *this;}}
18-3218.4 Developing the complex 18.4 Developing the complex ClassClass
This complex number class acts as a review for operator overloading
Think of a complex number as one point on the Cartesian (complex) plane.
The point is usually written as (1, 2) where 1 is the number on the real axis (x axis) and 2 is a value on the imaginary axis (y axis).
18-33Imaginary AxisImaginary Axis
¦¦
3i +3i +
¦¦ (3.0, 2.0) (3.0, 2.0)
2i + 2i +
(-2.0, 1.0) ¦(-2.0, 1.0) ¦
i +i +
¦ (3.5, 0.0) ¦ (3.5, 0.0)
-+---+---+---+---+---+---+--+---+----+---+---+---+---+---+---+--+---+--- Real AxisReal Axis
-3 -2 1 0¦ 1 2 3 4 5-3 -2 1 0¦ 1 2 3 4 5
-i +-i +
¦(1.5, -2.0)¦(1.5, -2.0)
-2i + -2i +
(-3.0, -3.0) ¦(-3.0, -3.0) ¦
-3i +-3i +
¦¦
18-34 Complex numbersComplex numbers
Complex numbers are used a lot in certain fields Complex numbers are used a lot in certain fields electrical engineering for exampleelectrical engineering for example
Standard C++ now has a complex classStandard C++ now has a complex class we'll develop our ownwe'll develop our own
We'll consider a simple app:We'll consider a simple app: find the center of a trianglefind the center of a triangle
defined as the average of the three pointsdefined as the average of the three points sum three complex numbers and divide by threesum three complex numbers and divide by three see next slide see next slide
18-35 complex overloads +, /, <<complex overloads +, /, <<
#include <iostream>#include <iostream>using namespace std;using namespace std;#include "ltcomplx" #include "ltcomplx" // author-supplied// author-supplied complex classcomplex classint main()int main(){ { // construct three complex numbers// construct three complex numbers complex a(0, 0);complex a(0, 0); complex b(1, 1);complex b(1, 1); complex c(0.75, 2.15);complex c(0.75, 2.15); complex triangleCenter = (a + b + c) / 3.0;complex triangleCenter = (a + b + c) / 3.0; cout << "\nCenter of triangle (" << a << " + " cout << "\nCenter of triangle (" << a << " + " << b << " + " << c << ") / 3 is " << endl;<< b << " + " << c << ") / 3 is " << endl; cout << triangleCenter << endl;cout << triangleCenter << endl;}}
OutputOutputCenter of triangle ((0, 0) + (1, 1) + (0.75, 2.15)) / 3 isCenter of triangle ((0, 0) + (1, 1) + (0.75, 2.15)) / 3 is(0.583333, 1.05)(0.583333, 1.05)
18-36 18.4.2 Design18.4.2 Design
Want the complex class to handle complex Want the complex class to handle complex arithmetic as easily as real arithmetic with int arithmetic as easily as real arithmetic with int and doubleand double
like to have + - / * like to have + - / * like to allow input and outputlike to allow input and output there are a host of other complex function such as there are a host of other complex function such as
abs and sqrt abs and sqrt don't want programmers to have to remember and don't want programmers to have to remember and
perform complex multiplication and divisionperform complex multiplication and division
18-37 18.4.3 Implementation18.4.3 Implementation
Each complex number has a real part and an Each complex number has a real part and an imaginary partimaginary part
two doubles called my_real and my_imag could two doubles called my_real and my_imag could store the state of a complex objectstore the state of a complex object
We could have several constructorsWe could have several constructors default, one argument and 2 arguments to allowdefault, one argument and 2 arguments to allow
complex a;complex a; complex b( -1.0 ); complex b( -1.0 ); // the real number -1.0// the real number -1.0 complex b( 12.57, 1.99 );complex b( 12.57, 1.99 );
18-38Also overload some operators Also overload some operators as friend functionsas friend functions
class complex {class complex {public:public://--constructors//--constructors complex();complex(); // complex a;// complex a; complex(double initReal) complex(double initReal) // complex b(1.0);// complex b(1.0); complex(double initReal, complex(double initReal, // complex c(1.0. 2.0);// complex c(1.0. 2.0); double initImag); double initImag);
//--accessors//--accessors double real();double real(); double imag();double imag();
//--operator functions//--operator functions friend complex operator + (complex left, complex right);friend complex operator + (complex left, complex right); friend complex operator / (complex left, complex right);friend complex operator / (complex left, complex right); friend ostream& operator << (ostream& os, complex right);friend ostream& operator << (ostream& os, complex right); friend istream& operator >> (istream& is, complex& right);friend istream& operator >> (istream& is, complex& right);
private:private: double my_real;double my_real; double my_imag;double my_imag;};};
18-39 Overloading +Overloading +
complex operator + (complex left, complex right)complex operator + (complex left, complex right){ { // Complex addition // Complex addition // (a + bi) + (c + di) = (a + c) + (b + d)i // (a + bi) + (c + di) = (a + c) + (b + d)i
// a + c, the real part// a + c, the real part double tempReal = left.my_real + right.my_real; double tempReal = left.my_real + right.my_real;
// b + d, imaginary part// b + d, imaginary part double tempImag = left.my_imag + right.my_imag; double tempImag = left.my_imag + right.my_imag;
// Construct a complex object and return it// Construct a complex object and return it complex temp(tempReal, tempImag); complex temp(tempReal, tempImag); return temp; return temp; }}
18-40 Overloading << Overloading <<
The input and output operators can be The input and output operators can be overloaded for any new classoverloaded for any new class
in fact, the C++ system does this for all the in fact, the C++ system does this for all the standard typesstandard types
What has to be done:What has to be done: Make operator << it a friend for efficiencyMake operator << it a friend for efficiency take an ostream& parameter in addition to the take an ostream& parameter in addition to the
complex argumentcomplex argument return a reference to the changed ostreamreturn a reference to the changed ostream
18-41 operator <<operator <<
The left operator is an ostream object, cout for The left operator is an ostream object, cout for instance, the complex object is the rightinstance, the complex object is the right
cout << complex( 1.2, 3.4 ) << endl;cout << complex( 1.2, 3.4 ) << endl;
The return type is needed to allow chaining The return type is needed to allow chaining output together like thisoutput together like this
complex a, b, c;complex a, b, c; cout << a << b << c;cout << a << b << c;
cout << a returns the ostream you are cout << a returns the ostream you are outputting to so cout << b can occur nextoutputting to so cout << b can occur next
18-42 output it as you pleaseoutput it as you pleaseuse ( , and )use ( , and )
Here is the function heading as from ltcomplex.hHere is the function heading as from ltcomplex.h //--operator function//--operator function friend ostream& operator << (ostream& os, friend ostream& operator << (ostream& os, complex right);complex right);
Its implementationIts implementation ostream& operator << (ostream& os, complex right)ostream& operator << (ostream& os, complex right) {{ left << "(" << right.my_real << ", "left << "(" << right.my_real << ", " << right.my_imag << ")";<< right.my_imag << ")";
returnreturn os;os; }}
18-43 Complex number outputComplex number output
OutputOutput complex a(0.75, 2.15);complex a(0.75, 2.15); complex b(-1.5, 0.5);complex b(-1.5, 0.5); cout << a << " " << b << endl;cout << a << " " << b << endl;
OutputOutput (0.75, 2.15) (-1.5, 0.5)(0.75, 2.15) (-1.5, 0.5)
18-4418.4.7 Overloading >> for 18.4.7 Overloading >> for complex inputcomplex input
You can also input a complex number as two You can also input a complex number as two numbers in a rownumbers in a row
must overload >>must overload >> make it a friend function for efficiencymake it a friend function for efficiency need the left argument to be an istream object, cin need the left argument to be an istream object, cin
for examplefor example need a complex reference parameter need a complex reference parameter it must changeit must change return a reference to an ostream object to allow return a reference to an ostream object to allow
chaining of input like thischaining of input like this complex a, b, c;complex a, b, c; cin >> a >> b >> c;cin >> a >> b >> c;
18-45 input as you pleaseinput as you pleasethis just reads two numbersthis just reads two numbers
Here is the function heading as from ltcomplex.hHere is the function heading as from ltcomplex.h //--operator function//--operator function friend istream& operator >> (istream& is, friend istream& operator >> (istream& is, complex right);complex right);
Its implementationIts implementation istream& operator >> (istream& left, complex& right) istream& operator >> (istream& left, complex& right) { { double x, y; double x, y; // Get two numbers from the input stream is == cin// Get two numbers from the input stream is == cin is >> x >> y; is >> x >> y; // is is the same as cin// is is the same as cin // Now modify the right argument (c1)// Now modify the right argument (c1) right = complex(x, y); right = complex(x, y); return is; return is; };
18-46 Complex number outputComplex number output
OutputOutput complex a(0.75, 2.15);complex a(0.75, 2.15); complex b(-1.5, 0.5);complex b(-1.5, 0.5); cout << a << " " << b << endl;cout << a << " " << b << endl;
OutputOutput (0.75, 2.15) (-1.5, 0.5)(0.75, 2.15) (-1.5, 0.5)