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

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

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

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

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?

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

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; }

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

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

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 x y

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

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

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?

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

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)

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)

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; } junk x y junk x y w1 w2

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; } x y x y x y w1 w2

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; } void Point::plus(Point c) { //c is equal to w2 x += c.x; // x= y += c.y;// y= } x y x y x y w1 w2 w1 is the calling object so unqualified variables refer to w1

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; } void Point::plus(Point c) { //c is equal to w2 x += c.x; // x= y += c.y;// y= } x y x y x y w1 w2

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

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);

Updates to class definition //Create point with initialized values Point w1(0,0.5),w2(-0.5,1.5); //Create point with default values Point emptyPoint; void init(double u, double v) { x = u; y = v; } //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; }

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 int main() { 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; }

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; }

Updated main program //point2.cc int main() { 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)

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)

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