Week 3: Classes, constructors, destructors, new operator Operator and function overloading

1. Week 3: Classes, constructors, destructors, new operatorOperator and function overloading

2. Previous Knowledge • What is a class and why they are useful • Difference between class methods and instance methods • Public vs private and accessors and mutators (“getters” and “setters”) • Function override (i.e. __str__ in python) • Function overload

3. Objectives • Understand the syntax of: • Creating a class (template for type) • Providing default constructors and destructors • Adding other constructors • Accessing state variables using public accessors and mutators • Follow flow of execution for instance method invocation • Instantiating an instance of a class • Overload << operator to control printing

4. Classes • Expanded concept of data structure • Creates new data type composed of other data types • Combines data and operations on data • Cohesive structure that better models natural relationships • Requires a different kind of source file organization • Object oriented analysis and design

5. Initial class definition considerations • What data/fields defines a specific instance? • What operations are naturally used in conjunction with class? • Look over set of operators and consider if each has a natural context • Can they be added? • What does it mean to be equal? • Is there a natural ordering (used for comparison)? • If I print this object, what would be output?

6. Example • Point (2 dimensions) • Has x and y dimension <= data that defines a specific point • Can define the inverse point <= operation on data • We can add one point to another <= Addition has specific meaning in this context • Printing of a point should include value of x and y

7. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; }

8. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } class is keyword Point is the name of the class class definition is delimited by braces

9. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } items defined after public keyword can be used by any instantiating code i.e. public for all to see

10. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } classes have variables called attributes think of class attributes as defining a structure xy

11. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } items defined before public or after private keyword are not visible to the public i.e. for private use only

12. Point class class Point { private: double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } items defined before public or after private keyword are not visible to the public i.e. for private use only

13. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } Must initialize attributes to meaningful values ** What happens if init is never called? (the only function that sets x and y) ** Will it create a compile error?

14. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } • Longer functions are defined outside of the class definition • Classname:: denotes that the function is part of the class • Must still have function prototype in class definition

15. Point class class Point { double x, y; public : void plus(Point c); //function prototype void print() { cout << "(" << x << "," << y << ")"; } void init(double u, double v) { x = u; y = v; } }; void Point::plus(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; } • Since Point is a data type, it can be used as a parameter • plus is a mutator (changes x and y)

16. Main function int main() { Point w1, w2; w1.init(0, 0.5); w2.init(-0.5, 1.5); cout << "\npoint w1 = "; w1.print(); cout << "\npoint w2 = "; w2.print(); w1.plus(w2); cout << "\npoint w1 after plus = "; w1.print(); cout<<endl; } point w1 = (0,0.5) point w2 = (-0.5,1.5) point w1 after plus = (-0.5,2)

17. Main function int main() { //Declares/allocates w1 and w2 Point w1, w2; w1.init(0, 0.5); //sets the x and y value for w1 w2.init(-0.5, 1.5); //sets the x and y value for w2 cout << "\npoint w1 = "; w1.print(); //executes print with w1 data cout << "\npoint w2 = "; w2.print(); //executes print with w2 data w1.plus(w2); //calls plus cout << "\npoint w1 after plus = "; w1.print(); cout<<endl; } xy xy w2 w1 junk junk junk junk 20 21 22 23

18. Main function int main() { //Declares/allocates w1 and w2 Point w1, w2; w1.init(0, 0.5); //sets the x and y value for w1 w2.init(-0.5, 1.5); //sets the x and y value for w2 cout << "\npoint w1 = "; w1.print(); //executes print with w1 data cout << "\npoint w2 = "; w2.print(); //executes print with w2 data w1.plus(w2); //calls plus cout<< "\npoint w1 after plus = "; w1.print(); cout<<endl; } xy xy xy xy w2 w1 0.0 -0.5 0.5 1.5 20 21 22 23

19. Main function int main() { Point w1, w2; w1.init(0, 0.5); //sets the x and y value for w1 w2.init(-0.5, 1.5); //sets the x and y value for w2 cout << "\npoint w1 = "; w1.print(); //executes print with w1 data cout << "\npoint w2 = "; w2.print(); //executes print with w2 data w1.plus(w2); //calls plus cout << "\npoint w1 after plus = "; w1.print(); cout<<endl; } xy xy xy xy xy xy w2 w1 0.0 -0.5 0.05 1.5 20 21 22 23 void Point::plus(Point c){ //c is equal to w2 x += c.x; // x=0+-0.5 y += c.y;// y=0.5+1.5 } w1 is the calling object so unqualified variables refer to w1

20. Main function int main() { Point w1, w2; w1.init(0, 0.5); //sets the x and y value for w1 w2.init(-0.5, 1.5); //sets the x and y value for w2 cout << "\npoint w1 = "; w1.print(); //executes print with w1 data cout << "\npoint w2 = "; w2.print(); //executes print with w2 data w1.plus(w2); //calls plus cout << "\npoint w1 after plus = "; w1.print(); cout<<endl; } xy xy xy xy xy xy w2 w1 0.0 -0.5 0.05 1.5 20 21 22 23 void Point::plus(Point c) { //c is equal to w2 x += c.x; // x=0+-0.5 y += c.y;// y=0.5+1.5 }

21. Update using C++ constructs • Creation of objects using constructors rather than init function • Override adding one object to another using function overloading rather than creating print function This will affect both the class declaration and the invocation (how we use the methods in the main function

22. Constructors • Constructors are run when an object is created • It is a special function that different from other methods • Allows declaration, allocation and initialization of user defined types like native types //Create point with initialized values Point w1(0,0.5),w2(-0.5,1.5); //Create points with uninitialized attributes //and initialize with method Point w1, w2; w1.init(0, 0.5); w2.init(-0.5, 1.5);

23. Updates to class definition //signature has no return type and name of class (exact match) Point(double a, double b) { //in scope are parameter and attributes //can initialize class attributes x=a; y=b; } //Creates point with 0 and 0 as defaults Point() { x=0; y=0; } void init(double u, double v) { x = u; y = v; } //Create point with initialized values Point w1(0,0.5),w2(-0.5,1.5); //Create point with default values Point emptyPoint;

24. Update addition to use + operator • Update one point by adding another point to it (a bit awkward…will fix this Thursday) • Can use the addition(+) operator intmain() { Point emptyPoint,w1(0,0.5), w2(-0.5,1.5); cout << "\nTestingcreation of point with no parameters = "; emptyPoint.print(); cout << "\npoint w1 = "; w1.print(); cout << "\npoint w2 = "; w2.print(); w1+w2; cout << "\npoint w1 after plus = "; w1.print(); cout<<endl; }

25. Overloading addition operator //point2.cc class Point { double x, y; public : Point(){x=0;y=0;} Point(double a,double b) {x=a;y=b;} void operator+(Point c); //function prototype void print (){ cout << "(" << x << "," << y << ")";} }; void Point::operator+(Point c) { //definition not inline //offset the existing point by point c x += c.x; y += c.y; }

26. Updated main program //point2.cc intmain() { Point emptyPoint,w1(0,0.5), w2(-0.5,1.5); cout << "\nTesting creation of point with no parameters = "; emptyPoint.print(); cout << "\npoint w1 = "; w1.print(); cout << "\npoint w2 = "; w2.print(); w1+w2; cout << "\npoint w1 after plus = "; w1.print(); cout<<endl; } Testing creation of point with no parameters = (0,0) point w1 = (0,0.5) point w2 = (-0.5,1.5) point w1 after plus = (-0.5,2)

27. Recap • Class • user defined data type • combines data (attributes) and functions (methods) together • Constructors allow us to control the initialization of attributes upon creation • Redefine operator functions to use natural semantics (operator overloading)

28. Thursday • Destructors • Overloading the print function (operator <<) • Fixing addition to return a new object rather than mutate the existing object w3=w1+w2; • Friend functions • Accessors and mutators for encapsulation