1. 1 Building Classes (the "++" in C++) (Chapter 14) Representing More Complex Objects

2. Problem 2 Develop a type to model temperatures with various operations such as Fahrenheit/Celsius conversion, input, and output. However, a temperature object has two attributes its degrees (a double), and its scale (a character) and we can't represent it by a single type provided in C++. When this happens, we can create our own type by building a class to model the object (temperature) being represented. Other Examples: (Final Lab & Proj.) Coordinate objects: x-coordinate y-coordinate Fraction objects: numerator denominator Time objects: hours minutes seconds AM/PM

3. class Temperature { double myDegrees; char myScale; }; Such variables are called the class' data members (also referred to as instance variables or attribute variables). 3 Note the semicolon Function prototypes for built-in operations go here private: For a declaration C obj; where C is a class, the object obj is also called an "instance of C." When learning how to build classes, it helps to pretend that we are the temperature object ; beginning each attribute name with " my " helps reinforce this internal perspective. We begin by declaring variables to store the attributes of the object being represented (a temperature), and wrap these inside a class declaration in Temperature.h : Building a Class public:

4. Information Hiding Classes have a public section and a private section. (In fact, it may have more than one of each.) The public section provides the interface to users of the class; items declared in it are accessible to them. The private section contains implementation details. Items declared in it are inaccessible to users of the class and are said to be "hidden." Data members should go in the private section to prevent programmers from writing programs that access data members directly. 4 "What" a class provides "How" a class provides it Why? So users can't put invalid data in them. Also to allow changes to them in class revisions. e.g., in a Temperature object: set myScale = 'X' In a Fraction object: set myDenominator = 0

5. A New Type We have now created a new type Temperature, so we can use it in a program: #include "Temperature.h" // class Temperature... Temperature aTemp; The object aTemp can be visualized as follows: The data members myDegrees and myScale within aTemp are uninitialized. We need a way to put values in them. 5 myDegrees myScale aTemp ? ?

6. Operations and Messages As of now, our Temperature objects are just data containers (like structs in C) — they have no built-in ("push-button") operations by which users can process them. Instead they have to be "shipped off" to various functions for processing. So, our next task in building a class is to: Decide what operations to provide How to implement them 6 This may involve adding new data members

7. Operations on a class object are usually implemented as class function members (also called methods). To call a function member, we use the dot operator: object.method() 7 This can be thought of as the caller sending object a message named method. The definition of a function member details how object responds to the message. The "pushbutton" operator

8. Function Member Example: Output As we have noted, we have no way to put values in the data members of a Temperature object. Normally, function members (called constructors) that make this possible would be the first ones that we add to a class. However, we will instead look at an output operation because it is easier to understand. 8 Lab: Help with debugging other ops.

9. Suppose we want to display the value of a Temperature object aTemp by sending it a display() message: aTemp.display(cout); or aTemp.display(cerr); Using the internal perspective (where I am the Temperature object receiving the message), we have the following specification for the function member display() : Receive: An ostream object that we'll call out Output: myDegrees and myScale, via out. Pass back: out, containing the new values. 9

10. Function Member Prototypes class Temperature { public: void display(ostream & out) const; private: double myDegrees; char myScale; }; This informs the compiler that class Temperature has a function member named display(), and that Temperature objects should "understand" the display() message. It also makes this display() operation accessible to users of our class. 10 We declare prototypes of function members in the public section of a class:

11. Function Member Definitions void Temperature::display(ostream & out) const { out << myDegrees << ' ' << myScale; } The function returns nothing, so its return-type is void. The full name Temperature::display() tells the compiler this is a function member of class Temperature. This function receives an ostream that it needs to change (by outputting something into it) and pass back, so we need a reference parameter for it. Function members that are not allowed to change any data members should be declared as const function members. Definition of display() : 11

12. class Temperature {... }; // end of class declaration inline void Temperature::display(ostream & out) const { out << myDegrees << ' ' << myScale; } Definitions of function members usually go in the implementation (.cpp) file. But when they are simple (say, with 6 or fewer operations), they are, for efficiency, usually put in the header file, below the class declaration, and specified as inline — especially if they are called often. 12 Inlining a function allows the compiler to replace calls to it with the actual code of the definition, thus eliminating the overhead of a function call. Simple ordinary functions can also be inlined to improve a program's efficiency — see §10.4

13. Problem At present, a Temperature declaration Temperature aTemp; leaves aTemp 's data members uninitialized. So if we output it, aTemp.display(cout); we cannot expect any meaningful results — rather, "garbage." 13 It would be better if we could be assured that Temperature objects were auto-initialized to some meaningful default value (e.g., 0 C ). To accomplish this, we can use a special function member called a default constructor.

14. Constructors A class constructor is a function member whose task is to initialize the class' data members. Because all they do is initialize data members, they don't return anything, and so their specification is often given as a postcondition — a boolean expression that indicates the state of the object after the constructor terminates. Default Constructor Specification: Postcondition: myDegrees == 0 && myScale == 'C'. 14

15. Default Constructor Prototype class Temperature { public: Temperature(); void display(ostream & out) const; private: double myDegrees; char myScale; }; The name of a constructor is always the name of the class (in this case Temperature() ). Since it returns nothing, a constructor has no return type (not even void ). Since they specify the first thing a user of the class needs to know (i.e., how to define class objects), constructor prototypes are usually the first function members listed in the public section of the class. 15

16. Default Constructor Definition As a function member of class Temperature, its full name is Temperature::Temperature(). And because it is so simple and gets called often, we inline the definition and put it below the class declaration in Temperature.h. // In Temperature.h, after class declaration inline Temperature::Temperature() { myDegrees = 0; myScale = 'C'; } 16

17. Object Declarations A programmer can now make declarations like Temperature aTemp; and object can be visualized as follows: and object aTemp can be visualized as follows: Each declaration of a class object will generate an automatic call to a class constructor. 17 myDegrees myScale aTemp 0.0 C

18. Testing //... documentation //... other #includes #include "Temperature.h" int main() { Temperature aTemp; aTemp.display(cout); } 18 To test this, we can write: To test this much, we can write: Lab: fractionTester.cpp Execution : 0 C

19. Problem 2 At present, we can only initialize a Temperature object to a default value: Temperature aTemp;, w. The mechanism that makes it possible to initialize an object to other values is function overloading, which allows two different functions to have the same name. The same name can be used to define different functions, provided each function has a different signature (the list of the parameter types). The compiler will determine which function to use from the number and type of arguments in a function call. 19

20. Another Constructor So, to overload the constructor, we just provide a second constructor that differs from all other constructors in at least one parameter type. 20 But this is easy; we simply have the second constructor — called an explicit-value constructor — receive the initial values we want a Temperature object to have via its parameters and use these parameter values to initialize the class' data member. Explicit-Value Constructor Specification: Receive: degrees, a double; scale, a char. Precondition: scale == 'F' || scale == 'C'. Postcondition: myDegrees == degrees && myScale == scale. State of the object

21. Explicit-Value Constructor Prototype class Temperature { public: Temperature(); Temperature(double degrees, char scale); void display(ostream & out) const; private: double myDegrees; char myScale; }; 21

22. As before, because of its simplicity and constructors get called often, we put this (second) constructor definition in Temperature.h below the class declaration and inline it. // In Temperature.h, after class declaration inline Temperature::Temperature(double degrees, char scale) { assert(scale == 'F' || scale == 'C'); myDegrees = degrees; myScale = scale; } 22 Explicit-Value Constructor Definition

23. Object Definitions A programmer can now write: Temperature temp1, and temp1 and temp2 are defined as follows: The compiler uses the number of arguments in a declaration to decide which constructor to use in initializing an object. myDegrees myScale temp1 C 0.0 myDegrees myScale temp2 F 98.6 23 Default constructor Explicit-value constructor temp2(98.6, 'F');

24. Testing To test this much, we can write: //... documentation //... other #includes #include "Temperature.h" int main() { Temperature temp1, temp2(98.6, 'F'); temp1.display(cout); cout << endl; temp2.display(cout); } 24 Execution : 0 C 98.6 F

25. 25 /*---- Temperature.h ----------------------------------------------- Header file for Temperature class. Operations: Constructors: default display(): output a Temperature object ------------------------------------------------------------------*/ #include class Temperature { public: Temperature(); Temperature(double degrees, char scale); void display(ostream & out) const; private: double myDegrees; char myScale; }; //-- Definition of default constructor inline Temperature::Temperature() { myDegrees = 0; myScale = 'C'; } Our Temperature Class... so far and explicit-value

26. 26 //-- Definition of display() inline void Temperature::display(ostream & out) const { out << myDegrees << ' ' << myScale; } /*---- Temperature.cpp --------------------------------------------- Implementation file for Temperature class. ------------------------------------------------------------------*/ //-- STILL EMPTY //-- Definition of explicit-value constructor inline Temperature::Temperature(double degrees, char scale) { assert(scale == 'F' || scale == 'C'); myDegrees = degrees; myScale = scale; }

27. 27 /*--------------------------------------------------------------- Explicit-value constructor Receive: degrees, a double; scale, a char. Precondition: scale == 'F' || scale == 'C'. Postcondition: myDegrees == degrees && myScale == scale. ----------------------------------------------------------------*/ Temperature(double degrees, char scale); /*---- Temperature.txt --------------------------------------------- Documentation file for Temperature class. Operations: Constructors: default and explicit-value display(): output a Temperature object read(): input a Temperature object ------------------------------------------------------------------*/ class Temperature { public: /*--------------------------------------------------------------- Default constructor Postcondition: myDegrees == 0 && myScale == 'C'. ----------------------------------------------------------------*/ Temperature();

28. 28 /*--------------------------------------------------------------- Output function member Receive: out, an ostream. Output: myDegrees and myScale, via out. Passback: out, containing the new values. ----------------------------------------------------------------*/ void display(ostream & out) const; private: double myDegrees; char myScale; }; /*---- tempTester.cpp ------------------------------------------ Driver program to test Temperature class ---------------------------------------------------------------*/ #include using namespace std; #include "Temperature.h" int main() { Temperature temp1; temp1.display(cout); // displays 0 C cout << endl; temp2.display(cout); // displays 98.6 F cout << endl; } Execution : 0 C 98.6 F, temp2(98.6, 'F');

29. Accessor Functions The values in the data members of a Temperature object are not accessible to a user of our class. To make them available, we provide function members, called accessor functions, that retrieve these values: 29 class Temperature { public: Temperature(); Temperature(double degrees, char scale); double getDegrees() const; char getScale() const; private: double myDegrees; char myScale; }; const because they only access data members, don't modify them.

30. inline double Temperature::getDegrees() const { return myDegrees; } inline char Temperature::getScale() const { return myScale; } Because they are simple one-line functions, they can be defined in the header file as inline functions. 30 Temperature temp1; //... cout << "Its degrees is " << temp1.getDegrees() << " and its scale is " << temp1.getScale() << endl; Use in a program:

31. Input It is also useful to be able to input a value for a Temperature object. From the internal perspective, we can specify this task as follows. 31 Specification: Receive: in, an istream. Precondition: in contains valid degrees and scale values. Input: the degrees and scale values from in. Passback: in, minus its degrees and scale values. Postcondition: myDegrees == degrees && myScale == scale.

32. Input: Prototype Note that unlike output, the input operation changes the class data members, and so is not a const function. 32 class Temperature { public: Temperature(); Temperature(double degrees, char scale); void read(istream & in); void display(ostream & out) const; double getDegrees() const; char getScale() const; private: double myDegrees; char myScale; };

33. Input: Definition void Temperature::read(istream & in) { double degrees; char scale; in >> degrees >> scale; scale = toupper(scale); // Change 'f', 'c' // Check precondition assert(scale == 'C' || scale == 'F'); myDegrees = degrees; // Valid input, so myScale = scale; // set data members } Input is an easy place for errors to occur, so always carefully check the preconditions of an input function. We put this in Temperature.cpp rather than inline it like we did display() since it's more complicated. 33 Temporary holding area for input so we can validate it before putting it in the data members

34. Testing //... documentation //... other #includes #include "Temperature.h" int main() { cout << "\nEnter a temperature: "; Temperature temp3; temp3.read(cin); // read it temp3.display(cout); // echo it back cout << endl; } 34 Execution : Enter a temperature: 32F 32 F

35. Conversion Functions To find the Celsius or Fahrenheit equivalent of a Temperature object, we want to be able to send it a toCelsius() or toFahrenheit() message: Temperature temp1, temp2; //... temp2 = temp1.toCelsius(); //... temp1 = temp2.toFahrenheit(); From the internal perspective, our specifications are: toCelsius(): Return the Celsius equivalent of myself. toFahrenheit(): Return the Fahrenheitequivalent of myself. 35

36. Conversion-function Prototypes These operations won't alter the class data members, and so are declared as const function members. class Temperature { public: Temperature(); Temperature(double degrees, char scale); void read(istream & in); void display(ostream & out) const; double getDegrees() const; char getScale() const; Temperature toCelsius() const; Temperature toFahrenheit() const; private: double myDegrees; char myScale; }; 36

37. Conversion-function Definitions Temperature Temperature::toCelsius() const { switch (myScale) { case 'C': return Temperature(myDegrees, 'C'); case 'F': return Temperature((myDegrees - 32)/1.8, 'C'); default: cerr << "\nInvalid scale: " << myScale << " in Celsius().\n" << endl; exit(1); } 37 In Temperature.cpp Temperature Temperature::toFahrenheit() const { switch (myScale) { case 'F': return Temperature(myDegrees, 'F'); case 'C': return Temperature(1.8 * myDegrees + 32), 'F'); default: cerr << "\nInvalid scale: " << myScale << " in Celsius().\n" << endl; exit(1); } Note how our explicit-value constructor is used to build the return values.

38. Testing #include "Temperature.h" int main() { cout << "\nEnter a temperature: "; Temperature temp1, temp2; temp1.read(cin); temp2 = temp1.toCelsius(); temp2.display(cout); // or we can chain the messages together: // temp1.toCelsius().display(cout); cout << endl; temp1 = temp2.toFahrenheit(); temp1.display(cout); cout << endl; } 38 We test the correctness of this function in the tester program on slides 55-56.

39. An Arithmetic Operator:  (subtraction) Nearly any C++ operator  can be overloaded for a new type by defining a function named operator  () for that type. For example, if a and b are int s, we could write the expression a + b as the function call operator+(a, b). If a and b are objects of type C (where C is a class), two different versions of this function are possible; for example, a.operator+(b), if operator+() is a function member of C operator+(a, b), an ordinary function otherwise 39 For our Temperature class, either method could be used to define a subtraction operation, but we will use the first. So we have the following internal specification for our function operator-() : Receives: a Temperature object temp2 Returns: The difference between myself and temp2

40. Prototype Since this operation won't alter the class data members, it is declared as a const function member. 40 class Temperature { public: Temperature(); Temperature(double degrees, char scale); void read(istream & in); void display(ostream & out) const; double getDegrees() const; char getScale() const; Temperature toCelsius() const; Temperature toFahrenheit() const; Temperature operator-(const Temperature & temp2) const; private: double myDegrees; char myScale; };

41. Definition Temperature Temperature::operator- (const Temperature & temp2) const { Temperature result; if (myScale == 'F') { result.myDegrees = myDegrees - temp2.toFahrenheit().getDegrees(); result.myScale = 'F'; } else { result.myDegrees = myDegrees - temp2.toCelsius().getDegrees(); result.myScale = 'C'; } return result; } 41 In Temperature.cpp We test the correctness of this function in the tester program on slides 55-56.

42. The Output Operator << Instead of writing: temp1.display(cout); cout << endl; that is, overload << for our Temperature class. We can do this by defining the function operator<<() for it. However, because the left operand ( cout ) is an ostream object and not a Temperature object (and we are unable to modify the ostream class), we cannot implement this operation as a function member of the Temperature class. So we define it as an ordinary function with two parameters, an ostream and a Temperature ; i.e., cout << temp1 is the same as operator<<(cout, temp1) it would be more convenient if we could write: cout << temp1 << endl; 42

43. Definition // In Temperature.h, after the class declaration inline ostream & operator<<(ostream & out, const Temperature & temp) { temp.display(out); return out; } 43 Notes about this definition: operator<<() is not a function member, so:  It is not prototyped inside the class declaration  It's name is not qualified by Temperature:: Because of it's simplicity, we inline this definition and put it below the class declaration in Temperature.h. Note: No Temperature::

44. 44 The function must modify the actual ostream it receives via out (because output is inserted into it ), so out must be a reference parameter. Chaining << operations together as in cout << temp1 << endl; is executed as a composition of function calls: operator<<( operator<<(cout,temp1), endl); This means that the first function call must return the ostream out to which it is sending output so the second function call can use it. However, the normal function-return mechanism makes a copy of what is returned and we need to return out, not a copy of out. This copying mechanism can be turned off by making the function's return type a reference ( ostream & ).

45. The Input Operator >> Similar to output, it would be more convenient if instead of temp1.read(cin); temp2.read(cin); And we can do this in a manner similar to that for output by defining an ordinary function named operator>> that uses our read() function member. to input two Temperature objects, we could write: cin >> temp1 >> temp2; 45 // In Temperature.h, after the class declaration inline istream & operator>>(istream & in, Temperature & temp) { temp.read(in); return in; } One difference: temp isn't a constant reference parameter since it must be changed.

46. 46 /*---- Temperature.h ----------------------------------------------- Header file for Temperature class. Operations: Constructors: default and explicit-value display(): output a Temperature object read(): input a Temperature object getDegrees(), getScale(): accessors toCelsuis(): Fahrenheit to Celsius converter toFahrenheit(): Celsuis to Fahrenheit converter > : output and input operators ------------------------------------------------------------------*/ #include class Temperature { public: Temperature(); Temperature(double degrees, char scale); void display(ostream & out) const; void read(istream & in); double getDegrees() const; char getScale() const; Temperature toCelsius() const; Temperature toFahrenheit() const; Temperature operator-(const Temperature & temp2) const; private: double myDegrees; char myScale; }; Our Complete Temperature Class

47. 47 //-- Definition of default constructor inline Temperature::Temperature() { myDegrees = 0; myScale = 'C'; } //-- Definition of explicit-value constructor inline Temperature::Temperature(double degrees, char scale) { assert(scale == 'F' || scale == 'C'); myDegrees = degrees; myScale = scale; } //-- Definition of display() inline void Temperature::display(ostream & out) const { out << myDegrees << ' ' << myScale; } //-- Definition of getDegrees() inline double Temperature::getDegrees() const { return myDegrees; } //-- Definition of getScale() inline char Temperature::getScale() const { return myScale; }

48. 48 /*---- Temperature.cpp --------------------------------------------- Implementation file fzor Temperature class. ------------------------------------------------------------------*/ #include using namespace std; #include "Temperature.h" //-- Defininition of << inline ostream & operator<<(ostream & out, const Temperature & temp) { temp.display(out); return out; } //-- Defininition of >> inline istream & operator>>(istream & in, Temperature & temp) { temp.read(in); return in; }

49. 49 //-- Definition of read() void Temperature::read(istream & in) { double degrees; char scale; in >> degrees >> scale; scale = toupper(scale); // Check for 'f', 'c' // Check precondition assert(scale == 'C' || scale == 'F'); myDegrees = degrees; // Valid input, so myScale = scale; // set data members } //-- Definition of toCelsius() Temperature Temperature::toCelsius() const { switch (myScale) { case 'C': return Temperature(myDegrees, 'C'); case 'F': return Temperature((myDegrees - 32)/1.8, 'C'); default: cerr << "\nInvalid scale: " << myScale << " in Celsius().\n" << endl; exit(1); }

50. 50 //-- Definition of toFahrenheit() Temperature Temperature::toFahrenheit() const { switch (myScale) { case 'F': return Temperature(myDegrees, 'F'); case 'C': return Temperature(myDegrees * 1.8 + 32, 'F'); default: cerr << "\nInvalid scale: " << myScale << " in toFahrenheit().\n" << endl; exit(1); } //-- Definition of operator-() Temperature Temperature::operator-(const Temperature & temp2) const { Temperature result; if (myScale == 'F') { result.myDegrees = myDegrees - temp2.toFahrenheit().getDegrees(); result.myScale = 'F'; } else { result.myDegrees = myDegrees - temp2.toCelsius().getDegrees(); result.myScale = 'C'; } return result; }

51. 51 /*---- Temperature.txt --------------------------------------------- Documentation file for Temperature class. Operations: Constructors: default and explicit-value display(): output a Temperature object read(): input a Temperature object getDegrees(), getScale: accessors toCelsuis(): Fahrenheit to Celsius converter toFahrenheit(): Celsuis to Fahrenheit converter > : output and input operators ------------------------------------------------------------------*/ class Temperature { public: /*--------------------------------------------------------------- Default constructor Postcondition: myDegrees == 0 && myScale == 'C'. ----------------------------------------------------------------*/ Temperature(); /*--------------------------------------------------------------- Explicit-value constructor Receive: degrees, a double; scale, a char. Precondition: scale == 'F' || scale == 'C'. Postcondition: myDegrees == degrees && myScale == scale. ----------------------------------------------------------------*/ Temperature(double degrees, char scale);

52. 52 /*--------------------------------------------------------------- Output function member Receive: out, an ostream. Output: myDegrees and myScale, via out. Passback: out, containing the new values. ----------------------------------------------------------------*/ void display(ostream & out) const; /*--------------------------------------------------------------- Input function member Receive: in, an istream. Input: degrees and scale, via in Precondition: scale == 'F' || scale == 'C' (lower case allowed) Passback: in, with the values removed ----------------------------------------------------------------*/ void read(istream & in); /*--------------------------------------------------------------- Degrees accessor Returns: Value of myDegrees ----------------------------------------------------------------*/ double getDegrees() const; /*--------------------------------------------------------------- Scale accessor Returns: Value of myScale ----------------------------------------------------------------*/ char getScale() const;

53. 53 /*--------------------------------------------------------------- Fahrenheit to Celsius converter Returns: Celsius equivalent of this Temperature object ----------------------------------------------------------------*/ Temperature toCelsius() const; /*--------------------------------------------------------------- Celsius to Fahrenheit converter Returns: Fahrenheit equivalent of this Temperature object ----------------------------------------------------------------*/ Temperature toFahrenheit() const; /*--------------------------------------------------------------- Subtraction Operator Recieves: Temperature object temp2 Returns: (This Temperature object) - temp2 ----------------------------------------------------------------*/ Temperature operator-(const Temperature & temp2) const; private: double myDegrees; char myScale; };

54. 54 /*--------------------------------------------------------------- Output operator << Receive: out, an ostream and Temperature object aTemp. Output: myDegrees and myScale values in aTemp, via out. Passback: out, containing the new values. Return: reference to out. ----------------------------------------------------------------*/ ostream & operator<<(ostream & out, const Temperature & aTemp); /*--------------------------------------------------------------- Input function member Receive: in, an istream. Input: degrees and scale, via in Precondition: scale == 'F' || scale == 'C' (lower case allowed) Postcondition: aTemp's data members are set to degrees and scale, respectively. Passback: in, with the values removed, and aTemp. ----------------------------------------------------------------*/ istream & operator>>(istream & in, Temperature & temp);

55. 55 /*---- tempTester.cpp ------------------------------------------ Driver program to test Temperature class ---------------------------------------------------------------*/ #include using namespace std; #include "Temperature.h" int main() { Temperature temp1, temp2(98.6, 'F'), temp3, temp4; temp1.display(cout); // displays 0C cout << endl; temp2.display(cout); // displays 98.6F cout << endl; cout << "\nEnter a temperature: "; temp3.read(cin); // read a Temperature temp3.display(cout); // echo it back cout << endl; cout << "Its degrees is " << temp3.getDegrees() << " and its scale is " << temp3.getScale() << endl; temp4 = temp3.toCelsius(); cout << "Its Celsius equivalent is: "; temp4.display(cout); cout << "\nand the Fahrenheit equivalent of this is: "; temp4.toFahrenheit().display(cout); cout << endl;

56. 56 temp4 = temp1 - temp3; cout << "(First original temperature) - (this temperature) is "; temp4.display(cout); temp4 = temp2 - temp3; cout << "\n(Second original temperature) - (this temperature) is "; temp4.display(cout); cout << endl; cout > and <<\n" << "Enter two temperatures: "; cin >> temp1 >> temp2; cout << "First temperature is " << temp1 << " and the second is " << temp2 << endl; } Execution : 0 C 98.6 F Enter a temperature: 88.1 F 88.1 F Its degrees is 88.1 and its scale is F Its Celsius equivalent is: 31.1167 C and the Fahrenheit equivalent of this is: 88.1 F (First original temperature) - (this temperature) is -31.1167 C (Second original temperature) - (this temperature) is 10.5 F Now, let's try I/O with >> and << Enter two temperatures: 111.1F 44.4C First temperature is 111.1 F and the second is 44.4 C Note that these statements test not only I/O of a Temperature object, but also that chaining of the > operators works:

57. 57 class Coordinate { public: Coordinate(); Coordinate(double x, double y); double getX() const; double getY() const; void read(istream & in); void display(ostream & out) const; Coordinate operator+(const Coordinate & point2) const; private: double myX, myY; }; Coordinate Coordinate::operator+(const Coordinate & point2) const { Coordinate result( ); return result; } myX + point2.getX(), myY + point2.getY()

58. 58