Ch 14. Inheritance. September 10, Prof. Young-Tak Kim

Transcription

1 Ch 14. Inheritance September 10, 2013 Advanced Networking Technology Lab. (YU-ANTL) Dept. of Information & Comm. Eng, Graduate School, Yeungnam University, KOREA (Tel : ; Fax : ytkim@yu.ac.kr)

2 Outline Inheritance Basics Derived classes, with constructors protected: qualifier Redefining member functions Non-inherited functions Programming with Inheritance Assignment operators and copy constructors Destructors in derived classes Multiple inheritance ch 14-2

3 Introduction to Inheritance Object-oriented programming Powerful programming technique Provides abstraction dimension called inheritance General form of class is defined Specialized versions then inherit properties of general class And add to it/modify it s functionality for it s appropriate use ch 14-3

4 Inheritance Inheritance is a way of creating a new class by starting with an existing class and adding new members The new class can replace or extend the functionality of the existing class Inheritance models the is a relationship between classes; not has a relationship ch 14-4

5 Inheritance - Terminology The existing class is called the base class Alternates: parent class, superclass The new class is called the derived class Alternates: child class, subclass // Existing class class Base { }; Inheritance Class Diagram Base Class // Derived class class Derived : Base { }; Derived Class ch 14-5

6 Inheritance (1) a mechanism that lets the programmer create new objects based on old ones (which are proven in performance and reliability) the child object inherits the qualities of a parent object provides ease of maintenance: when some changes are required for all the similar objects that have been inherited from the same parent object, only the parent objects needs to change Diagram name 1 * Figure color centerposition penthickness pentype move() select() rotate() display() ZeroDimension OneDimension orientation scale() TwoDimension orientation filltype scale() fill() Point display() Line endpoints display() Arc radius startangle arcangle display() Spline controlpts display() Polygon numofsides vertices display() Circle diameter display() rotate() ch 14-6

7 Inheritance (2) the derived classes contains all attributes of the parent class the parent class is providing more generic attributes the derived (children) classes specify more specific features class student - name - student_id - department - gpa class under_student - internships - class: freshman, sophomore, junior, senior class grad_student - course: ms or Phd - advisor of thesis - publications ch 14-7

8 Inheritance Basics New class inherited from another class Base class "General" class from which others derive Derived class New class Automatically has base class s: Member variables Member functions Can then add additional member functions and variables ch 14-8

9 Derived Classes Consider example: Class of "Employees" Composed of: Salaried employees Hourly employees Each is "subset" of employees Another might be those paid fixed wage each month or week ch 14-9

10 Derived Classes Don t "need" type of generic "employee" Since no one s just an "employee" General concept of employee helpful! All have names All have social security numbers Associated functions for these "basics" are same among all employees So "general" class can contain all these "things" about employees ch 14-10

11 Inheritance of Members class Parent { int a; void bf(); }; class Child : Parent { int c; void df(); }; Objects of Parent have members int a; void bf(); Objects of Child have members int a; void bf(); int c; void df(); Child Parent - int a - void bf() -int c -void df() ch 14-11

12 Type Compatibility in Inheritance Hierarchies Classes in a program may be part of an inheritance hierarchy Classes lower in the hierarchy are special cases of those up higher Wild_Animal Animal Farm_Animal Lion Tiger Pig Sheep ch 14-12

13 Employee Class Many members of "employee" class apply to all types of employees Accessor functions: getssn(); Mutator functions: setssn(); Most data items: SSN //Social Security Number Name Pay We won t have "objects" of this class, however ch 14-13

14 Employee Class Consider printcheck() function: Will always be "redefined" in derived classes So different employee types can have different checks Makes no sense really for "undifferentiated employee So function printcheck() in Employee class says just that Error message stating "printcheck called for undifferentiated employee!! Aborting " ch 14-14

15 Deriving from Employee Class Derived classes from Employee class: Automatically have all member variables Automatically have all member functions Derived class said to "inherit" members from Base class Can then redefine existing members and/or add new members ch 14-15

16 Interface for the Derived Class HourlyEmployee (1) /** employee.h */ #include <string> using std::string; class Employee { public: Employee( ); Employee(string thename, string thessn); string getname( ); string getssn( ); double getnetpay( ); void setname(string newname); void setssn(string newssn); void setnetpay(double newnetpay); void printcheck( ); protected: string name; string ssn; double netpay; }; ch 14-16

17 Interface for the Derived Class HourlyEmployee (2) ch 14-17

18 Interface for the Derived Class HourlyEmployee (3) ch 14-18

19 HourlyEmployee Class Interface Note definition begins same as any other #ifndef structure Includes required libraries Also includes employee.h! And, the heading: class HourlyEmployee : public Employee { } Specifies "publicly inherited" from Employee class ch 14-19

20 HourlyEmployee Class Additions Derived class interface only lists new or "to be redefined" members Since all others inherited are already defined i.e.: "all" employees have ssn, name, etc. HourlyEmployee adds: Constructors wagerate, hours member variables setrate(), getrate(), sethours(), gethours() member functions ch 14-20

21 HourlyEmployee Class Redefinitions HourlyEmployee redefines: printcheck() member function This "overrides" the printcheck() function implementation from Employee class Its definition must be in HourlyEmployee class s implementation As do other member functions declared in HourlyEmployee s interface New and "to be redefined" ch 14-21

22 Inheritance Terminology Common to simulate family relationships Parent class Refers to base class Child class Refers to derived class Ancestor class Class that is a parent of a parent Descendant class Opposite of ancestor ch 14-22

23 Constructors in Derived Classes Base class constructors are NOT inherited in derived classes! But they can be invoked within derived class constructor Which is all we need! Base class constructor must initialize all base class member variables Those inherited by derived class So derived class constructor simply calls it "First" thing derived class constructor does ch 14-23

24 Derived Class Constructor Example Consider syntax for HourlyEmployee constructor: HourlyEmployee::HourlyEmployee(string thename, string thessn, double thewagerate, double thehours) : Employee(theName, thessn), wagerate(thewagerate), hours(thehours) { //Deliberately empty } Portion after : is "initialization section" Includes invocation of Employee constructor ch 14-24

25 Another HourlyEmployee Constructor A second constructor: HourlyEmployee::HourlyEmployee() : Employee(), wagerate(0), hours(0) { //Deliberately empty } Default version of base class constructor is called (no arguments) Should always invoke one of the base class s constructors ch 14-25

26 Constructor: No Base Class Call Derived class constructor should always invoke one of the base class s constructors If you do not: Default base class constructor automatically called Equivalent constructor definition: HourlyEmployee::HourlyEmployee() : wagerate(0), hours(0) {.... } ch 14-26

27 Pitfall: Base Class Private Data Derived class "inherits" private member variables But still cannot directly access them Not even through derived class member functions! Private member variables can ONLY be accessed "by name" in member functions of the class they re defined in ch 14-27

28 Pitfall: Base Class Private Member Functions Same holds for base class member functions Cannot be accessed outside interface and implementation of base class Not even in derived class member function definitions ch 14-28

29 Pitfall: Base Class Private Member Functions Impact Larger impact here vs. member variables Member variables can be accessed indirectly via accessor or mutator member functions Member functions simply not available This is "reasonable" Private member functions should be simply "helper" functions Should be used only in class they re defined ch 14-29

30 The protected: Qualifier New classification of class members Allows access "by name" in derived class But nowhere else Still no access "by name" in other classes In class it s defined acts like private Considered "protected" in derived class To allow future derivations Many feel this "violates" information hiding ch 14-30

31 Private vs. Protected Class Base { private: int x; public: int getx1( ); }; 2 1 Class Base { protected: int x; public: int getx1( ); }; Direct Access by Name! Class Derived : Base { private: int y; public: int gety() int getx2( ); } Class Derived : Base { private: int y; protected: int getx2( ); public: int gety() } ch 14-31

32 Inheritance Modes in public inheritance, the classifiers in base class are not changed in protected inheritance, the public classifier in base class is changed to protected classifier in derived class in private inheritance, the public and protected classifier in base class are changed to private classifier in derived class base class members classifier Public Inheritance Protected Inheritance Private Inheritance Public Public Protected Private Protected Protected Protected Private Private Private Private Private ch 14-32

33 Redefinition of Member Functions Recall interface of derived class: Contains declarations for new member functions Also contains declarations for inherited member functions to be changed Inherited member functions NOT declared: Automatically inherited unchanged Implementation of derived class will: Define new member functions Redefine inherited functions as declared ch 14-33

34 Redefining vs. Overloading Very different! Redefining in derived class: SAME parameter list Essentially "re-writes" same function Overloading: Different parameter list Defined "new" function that takes different parameters Overloaded functions must have different signatures ch 14-34

35 A Function s Signature Recall definition of a "signature": Function s name Sequence of types in parameter list Including order, number, types Signature does NOT include: Return type const keyword & (call-by-reference) ch 14-35

36 Accessing Redefined Base Function When redefined in derived class, base class s definition not "lost" Can specify its use: Employee JaneE; HourlyEmployee SallyH; JaneE.printCheck(); calls Employee s printcheck function SallyH.printCheck(); calls HourlyEmployee printcheck function SallyH.Employee::printCheck(); Calls Employee s printcheck function! Not typical here, but useful sometimes ch 14-36

37 Functions Not Inherited All "normal" functions in base class are inherited in derived class Exceptions: Constructors (we ve seen) Destructors Copy constructor But if not defined, generates "default" one Recall need to define one for pointers! Assignment operator ( = ) If not defined default ch 14-37

38 Assignment Operators and Copy Constructors Recall: overloaded assignment operators and copy constructors NOT inherited But can be used in derived class definitions Typically MUST be used! Similar to how derived class constructor invokes base class constructor ch 14-38

39 Assignment Operator Example Given "Derived" is derived from "Base": Derived& Derived::operator =(const Derived & rightside) { Base::operator =(rightside); } Notice code line Calls assignment operator from base class This takes care of all inherited member variables Would then set new variables from derived class ch 14-39

40 Copy Constructor Example Consider: Derived::Derived(const Derived& Object) : Base(Object), { } After : is invocation of base copy constructor Sets inherited member variables of derived class object being created Note Object is of type Derived; but it s also of type Base, so argument is valid ch 14-40

41 Destructors in Derived Classes If base class destructor functions correctly Easy to write derived class destructor When derived class destructor is invoked: Automatically calls base class destructor! So no need for explicit call So derived class destructors need only be concerned with derived class variables And any data they "point" to Base class destructor handles inherited data automatically ch 14-41

42 Destructor Calling Order Consider: class B derives from class A class C derives from class B A B C When object of class C goes out of scope: Class C destructor called 1 st Then class B destructor called Finally class A destructor is called Opposite of how constructors are called ch 14-42

43 "Is a" vs. "Has a" Relationships Inheritance Considered an "Is a" class relationship e.g., An HourlyEmployee "is a" Employee A Convertible "is a" Automobile A class contains objects of another class as it s member data Considered a "Has a" class relationship e.g., One class "has a" object of another class as its data Example: HourlyEmployee is an Employee HourlyEmployee has a Date member variable (birthdate) ch 14-43

44 Protected and Private Inheritance New inheritance "forms" Both are rarely used Protected inheritance: class SalariedEmployee : protected Employee { } Public members in base class become protected in derived class Private inheritance: class SalariedEmployee : private Employee { } All members in base class become private in derived class ch 14-44

45 Multiple Inheritance Derived class can have more than one base class! Syntax just includes all base classes separated by commas: class derivedmulti : public base1, base2 { } Possibilities for ambiguity are endless! Dangerous undertaking! Some believe should never be used Certainly should only be used be experienced programmers! ch 14-45

46 Summary 14-1 Inheritance provides code reuse Allows one class to "derive" from another, adding features Derived class objects inherit members of base class And may add members Private member variables in base class cannot be accessed "by name" in derived Private member functions are not inherited ch 14-46

47 Summary 14-2 Can redefine inherited member functions To perform differently in derived class Protected members in base class: Can be accessed "by name" in derived class member functions Overloaded assignment operator not inherited But can be invoked from derived class Constructors are not inherited Are invoked from derived class s constructor ch 14-47

48 Homework Programming projects (Class Vehicle, Truck, Person) 14.2 Programming projects (Class Pet, Dog, Rock) ch 14-48

49 14.3 Object-oriented programming with inheritance (1) class Figure private data members: int pos_x, int pos_y, int angle, and string name public member functions: Figure(int x, int y, int a, string name); // constructor virtual double getarea();// returns 0.0 virtual double getvolume(); // returns 0.0 virtual void draw(); // prints out Draw_Figure at pos(x, y), name, virtual void print(); // prints out attributes of Figure void setpos_x(int x); void setpos_y(int y); int getpos_x(); // implement as inline function int getpos_y(); // implement as inline function int getangle();// implement as inline function string getname();// implement as inline function (2) class Ellipse class Ellipse (public) inherits from class Figure private data members: int radius1, radius2; // two sides (radiuses) of ellipse public member functions: Ellipse(int x, int y, int a, string name, int r1, int r2); // constructor virtual double getarea(); // calculates the area of ellipse (ellipse_area = PI*r1*r2) double getcircumference(); // calculates the circumference of ellipse // approximation of ellipse_circum = PI*{5*(r1+r2)/4 (r1*r2)/(r1+r2)} virtual double getvolume(); // returns 0.0 virtual void draw(); // prints out Draw_Ellipse at pos(x, y), name, virtual void print(); // prints out attributes of Ellipse int getradius1(); int getradius2(); void setradius1(int r1); // implement as inline function void setradius2(int r2); // implement as inline function ch 14-49

50 14.3 Object-oriented programming with inheritance (cont.) (3) class Cylinder class Cylinder (public) inherits from class Ellipse. private data member: int height; // height of cylinder public member functions: Cylinder(int x, int y, int a, string name, int r1, int r2, int h); // constructor virtual double getarea(); // calculates the surface area of cylinder virtual double getvolume(); // calculate the volume of cylinder virtual void draw(); // prints out Draw_Cylinder at pos(x, y), name, virtual void print(); // prints out attributes of Cylinder int getheight(); void setheight(int h); // implement as inline function ch 14-50

51 14.3 Object-oriented programming with inheritance (cont.) (4) main() function #include <iostream>.... void main() { Figure *figarray[5]; Figure f1(1, 2, 0, "Fig1"); f1.print(); cout << endl; Ellipse e1(3, 3, 0, "Ellipse1", 5, 5), e2(4, 4, 0, "Ellipse2", 6, 6); e1.print(); cout << endl; Cylinder c1(6, 6, 0, "Cyl1", 7, 7, 9), c2(7, 7, 0, "Cyl2", 8, 8, 9); c1.print(); cout << endl; figarray[0] = &f1; figarray[1] = &e1; figarray[2] = &e2; figarray[3] = &c1; figarray[4] = &c2; cout <<"Draw figures using polymorphism:" << endl; for (int i=0; i<5; i++) { figarray[i]->draw(); } cout << endl; } // end of main() ch 14-51