Week 3: Classes, constructors, destructors, new operator Operator and function overloading.
-
Upload
owen-banks -
Category
Documents
-
view
221 -
download
0
Transcript of Week 3: Classes, constructors, destructors, new operator Operator and function overloading.
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 classclass 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 classclass 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 keywordPoint is the name of the classclass definition is delimited by braces
Point classclass 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 classclass 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 attributesthink of class attributes as defining a structure
x y
Point classclass 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 classclass 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 classclass 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 classclass 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 classclass 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 functionint 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 functionint 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 junk
x y
20 21 junk junk
x y
22 23
w1 w2
Main functionint 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;}
0.0 0.5
x y
20 21 -0.5 1.5
x y
22 23
x y x yw1 w2
Main functionint 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=0+-0.5 y += c.y;// y=0.5+1.5}
0.0 0.05
x y
20 21 -0.5 1.5
x y
22 23
x y x yx y x yw1 w2
w1 is the calling object so unqualified variables refer to w1
Main functionint 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=0+-0.5 y += c.y;// y=0.5+1.5}
0.0 0.05
x y
20 21 -0.5 1.5
x y
22 23
x y x yx y x yw1 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 valuesPoint 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 valuesPoint w1(0,0.5),w2(-0.5,1.5);
//Create point with default valuesPoint 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 defaultsPoint() {
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(+) operatorint 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.ccclass 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.ccint 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 objectw3=w1+w2;
• Friend functions• Accessors and mutators for encapsulation