Andy Wang Object Oriented Programming in C++ COP 3330 Inheritance Andy Wang Object Oriented Programming in C++ COP 3330

Hierarchical Relationships Many types of classes share similarities Similar private member data Similar member functions Inheritance Factoring out common features into a single base class Build derived classes that will share or inherit all of the data and functionality of the base class Except constructors, destructors, and assignment operators

Inheritance The base class/derived class relationship is an “is a” relationship Derived object is an instance of the base object Usually a subcategory Vs. “has a” relationship An object of one class is embedded inside another class

Examples Base class Derived class GeometricObject Sport BankAccount Vehicle Car Circle, Square, Line Football, Baseball Savings, Checking Car, Train, Bus Honda, Toyota, Ford

Declaring Derived Class Format class derivedClassName : public baseClassName public The base class must be declared somewhere The derived class has the same level as the base class Other protection levels can be ignored for now

Examples class Sport {…}; class Football : public Sport {…}; class Baseball : public Sport {…}; class BankAccount {…}; class Checking : public BankAccount {…}; class Vehicle {…}; class Car : public Vehicle {…}; class Honda : public Car {…};

Note Car inherits everything in the Vehicle class Honda inherits everything in the Car class Thus, Honda inherits everything from the Vehicle class

Example: Drawing Program http://www.cs.fsu.edu/~myers/cop3330/examples/i nher/geombuild/geom1.h

geom1.h class GeometricObject { public: void Draw(); void Erase(); void Move(int h, int v); int top, left, bottom, right; };

geom1.h class Two_D_Object : public GeometricObject { public: int fillPattern; }; class Rectangle : public Two_D_Object { int length, width; }

Protection Levels Public Private Protected Can be accessed by name from anywhere Private Can be accessed directly only by the class in which it is declared Protected Can be accessed by directly by the class in which is declared and by any classes derived from that class

Example: Drawing class GeometricObject { public: GeometricObject(); void Draw(); void Erase(); void Move(int h, int v); protected: // accessible by this and derived classes int top, left, bottom, right private: int x; // inaccessible from outside };

Example: Drawing class Two_D_Object : public GeometricObject { public: Two_D_Object(); private: int fill Pattern; };

Example: Drawing class Rectangle : public Two_D_Object { public: Rectangle(); Rectangle(int t, int l, int b, int r, int f, int len, int wid); void FindCenter(int &, int &); void Draw(); double Area(); int Perimeter(); private: int length, width; };

Example: Drawing class Circle : public Two_D_Object { public: Circle(); Circle(int t, int l, int b, int r, int f, int cx, int cy, int rad); void FindCenter(int &, int &); void Draw(); double Area(); double Circumference(); private: int center_x, center_y, radius; };

Constructors in Derived Classes A derived object “is an” instance of the base class Thus, when a derived object is created, the constructors from the base and derived classes will run The base class will run first, then the derived

Examples Vehicle obj1; Car obj2; Honda obj3; Only the Vehicle() constructor runs Car obj2; Vehicle constructor runs, followed by the Car() constructor Honda obj3; Vehicle(), Car(), Honda()

Note Destructors will be invoked in the reverse order ~Honda(), ~Car(), ~Vehicle()

Examples http://www.cs.fsu.edu/~myers/cop3330/examples/i nher/sample.cpp

Inheritance #include <iostream> using namespace std; class A { public: A() { cout << “A()” << endl; } ~A() { cout << “~A” << endl; } };

Inheritance class B : public A { public: B() { cout << “B()” << endl; } ~B() { cout << “~B()” << endl; } }; class C : public B { C() { cout << “C()” << endl; } ~C() { cout << “~C()” << endl; }

Inheritance int main() { cout << “Declaring object of type A” << endl; A aobject; { cout << “Declaring object of type B” << endl; B bobject; cout << Declaring object of type C” << endl; C cobject;

Inheritance cout << “Object C now going out of scope” << endl; } cout << “Object B now going out of scope” << endl; cout << “Object A now going out of scope” << endl; return 0;

Constructors with Parameters Without parameters, the default constructors are called With a derived class, we might want to declare Honda h(2, 3, 4, “green”, “Accord”); 2 and 3 might be for variables like vehicleCategory and idNumber in the Vehicle Class 4 and “green” might be for variables like numDoors and carColor in the Car Class “Accord” might be for a variable model in the Honda class

How to Distribute the Parameters Use an initialization list function prototype : initialization list { function body } Use the initialization list to call the next higher constructor explicitly, in order to send the parameters to the parent constructor

Example Vehicle::Vehicle(int c, int id) { vehicleCategory = c; idNumber = id; } Car::Car(int c, int id, int nd, char *cc) : Vehicle(c, id) { numDoors = nd; strcpy(carColor, cc); Honda::Honda(int c, int id, int nd, char *cc, char *mod) : Car(c, id, nd, cc) { strcpy(model, mod);

Drawing Program Example http://www.cs.fsu.edu/~myers/cop3330/notes/inhe r1.html

geom.h class GeometriObject { public: GeometricObject(); GeometricObject(int t, int l, int b, int r); void Draw(); … protected: int top, left, bottom, right; };

geom.h class Two_D_Object : public GeometricObject { public: Two_D_Object(); Two_D_Object(int t, int l, int b, int r, int fill); … protected: int fillpattern; };

geom.h class Rectangle : public Two_D_Object { public: Rectangle(); Rectangle(int t, int l, int b, int r, int f, int len, int wid); … private: int length, width; };

geom.h class Circle : public Two_D_Object { public: Circle(); Circle(int , int l, int b, int r, int f, int cx, int cy, int rad); … private: int center_x, center_y, radius; };

geom.cpp #include <iostream> #include “geom.h” using namespace std; GeometricObject::GeometricObject() { cout << “Running GeometricObject default constructor\n”; top = left = bottom = right = 0; }

geom.cpp GeometricObject::GeometricObject(int t, int l, int b, int r) { cout << “Running GeometricObject constructor with parameters\n”; top = t; left = l; bottom = b; right = r; }

geom.cpp Two_D_Object::Two_D_Object() { cout << “Running Two_D_Object default constructor\n”; fillPattern = 0; } Two_D_Object::Two_D_Object(int t, int l, int b, int r, int fill) : GeometricObject(t, l, b, r) { cout << “Running Two_D_Object constructor with parameters\n”; fillPattern = fill;

geom.cpp Rectangle::Rectangle() { cout << “Running Rectangle default constructor\n”; length = width = 1; }

geom.cpp Rectangle::Rectangle(int , int l, int b, int r, int f, int len, int wid) : Two_D_Object(t, l, b, r, f) { cout << “Running Rectangle constructor with parameters\n”; length = len; width = wid; }

geom.cpp Circle::Circle() { radius = center_x = center_y = 1; } Circle::Circle(int t, int l, int b, int r, int f, int cx, int cy, int rad) : Two_D_Object(t, l, b, r, f) { center_x = cx; center_y = cy; radius = rad;

main.cpp #include <iostream> #include “geom.h” using namespace std; int main() { cout << “Rectangle r\n”; Rectangle r; cout << “Rectangle r1(1, 2, 3, 4, 5, 10, 20)\n”; Rectangle r1(1, 2, 3, 4, 5, 10, 20); return 0; }

Function Overriding Suppose we have the following base class class Student { public: void GradeReport(); … }; We also have the following derived classes class Grad : public Student class undergrad : public Student

Function Overriding Since Grad and Undergrad are derived from Student, they inherit everything from Student But suppose grade reports look different for undergrads and grads These classes need to have their own functions But using the exact same prototype

Function Overriding class Grad : public Student { public: void GradeReport(); … }; class Undergrad : public Student {

To Call the Parent Version void Student::GradeReport() { // processing done by parent function } void Grade::GradeReport() { // explicit call to parent function Student::GradeReport(); // other processing specific to Grad’s version

Drawing Example http://www.cs.fsu.edu/~myers/cop3330/examples/i nher/geom2/geom.h

geom.h class GeometricObject { public: … void Draw(); };

geom.h class Two_D_Object : public GeometricObject { public: … void Draw(); }

geom.h class Rectangle : public Two_D_Object { public: … void Draw(); };

geom.h class Circle: public Two_D_Object { public: … void Draw(); };

geom.cpp … void GeometricObject::Draw() { cout << “Running GeometricObject::Draw()\n” } void Two_D_Object::Draw() { cout << “Running Two_D_Object::Draw()\n”; // can call upon the base class version of Draw GeometricObject::Draw(); // and do any processing specific to this class cout << “Finishing Two_D_Object::Draw()\n”;

geom.cpp void Rectangle::Draw() { cout << “Running Rectangle::Draw()\n”; Two_D_Object::Draw(); // do pre-processing // draw rectangle cout << “Finishing Rectangle::Draw()\n”; } …

main.cpp #include <iostream> #include “geom.h” using namespace std; int main() { Rectangle r; … r.Draw(); return 0; }