storm.cis.fordham.edu

storm.cis.fordham.edu

Inheritance Chapter 15 & additional topics Overview Inheritance Introduction Three different kinds of inheritance Changing an inherited member function

More Inheritance Details Polymorphism Inheritance Introduction Motivating Example: Employee Classes Design a record-keeping program with records for salaried and hourly employees

Salaried and hourly employees belong to a class of people who share the property "employee" Salaried employee Hourly employees A subset of employees with a fixed wage Another subset of employees earn hourly wages All employees have a name and SSN

Functions to manipulate name and SSN are the same for hourly and salaried employees First define a class called Employee for all kinds of employees The Employee class will be used later to define classes for hourly and salaried employees employee.h Employee Employee()

name ssn net_pay Employee(string, string) print_check() get_name() get_ssn() get_net_pay() set_name()

set_ssn() set_net_pay() We now use Employee class to create an HourlyEmployee class see book Display 15.3 hourlyemployee.h HourlyEmployee is derived from Class Employee HourlyEmployee inherits all member functions

and member variables of Employee NOT SHOWN explicitly in HourlyEmployees defn The class definition begins class HourlyEmployee : public Employee note that :public Employee shows that HourlyEmployee is derived from class Employee HourlyEmployee declares additional member variables wage_rate and hours Employee Employee()

name ssn net_pay Employee(string, string) print_check() get_name() get_ssn() get_net_pay() set_name()

set_ssn() set_net_pay() is HourlyEmployee name Inheritance a new class, called a derived class, is created from another class (i.e., the base class) A derived class automatically has all the member variables and functions of the base class A derived class can have additional member variables and/ or member functions

ssn wage_rate hours net_pay Employee() Employee(string, string) print_check() get_name() get_ssn()

get_net_pay() set_name() set_ssn() set_net_pay() set_rate() get_rate() set_hours () get_hours () A derived class automatically has all the member variables and functions of the base

class. But, the derived class might not have the same access rights as the base class when accessing those inherited members! (To be discussed soon) Inherited Members A derived class inherits all the members (data members, functions) of the parent class The derived class should not re-declare or re-define a member function inherited from the parent unless

The derived class wants to use the inherited member function for doing something different The derived class can add member variables & member functions Display 15.3 hourlyemployee.h Only list the declaration of an inherited member function if you want to change the defn of the function.

Why re-define print_check() ? A practical concern here print_check will have different definitions to print different checks for each type of employee An Employee object lacks sufficient information to print a check Each derived class will have sufficient information to print a check employee.cpp employee.cpp Implementing a Derived Class Any member function added in the derived

class are defined in the implementation file for the derived class Definitions are not given for inherited functions that are not to be changed The HourlyEmployee class is implemented in Textbook Display 15.5 HourlyEmployee.cpp Display 15.5 (1/2) Display 15.5 (2/2)

We now use Employee class to create an SalariedEmployee class Class SalariedEmployee salariedemployee.h The class SalariedEmployee is also derived from Employee Function print_check is redefined to have a meaning specific to salaried employees SalariedEmployee adds a member variable

salary salariedemployee.cpp Display 15.6 (1/2) Display 15.6 (2/2) Parent and Child Classes Recall that a child class automatically has all the members of the parent class

The parent class is an ancestor of the child class The child class is a descendent of the parent class The parent class (Employee) contains all the code common to the child classes You do not have to re-write the code for each child Employee HourlyEmployee SalariedEmployee Parent and Child Classes (contd) An hourly employee is an employee

An object of type HourlyEmployee can be used wherever an object of type Employee can be used An object of a class type can be used wherever any of its ancestors can be used An ancestor cannot be used in a place where one of its descendents is expected void fun1(Employee x);

void fun2(HourlyEmployee y); int main() { Employee a; HourlyEmployee b; fun1(a); //correct fun1(b); //correct fun2(a); //incorrect fun2(b); //correct } public inheritance is an is-a relationship Derived Classs Constructors

A base classs constructor is not inherited in a derived class The base class constructor can be invoked by the constructor of the derived class The constructor of a derived class begins by invoking the constructor of the base class in the initialization section: HourlyEmployee::HourlyEmployee : Employee( ), wage_rate( 0), hours(0) { //no code needed } Call a constructor for Employee Default Initialization

If a derived class constructor does not invoke a base class constructor explicitly, the base class default constructor will be used automatically If class B is derived from class A and class C is derived from class B When a object of class C is created The base class A's constructor is the first invoked Class B's constructor is invoked next C's constructor completes execution

Private is Private A member variable (or function) that is private in the parent class is not directly accessible by the member functions in the child class This code is illegal as net_pay is a private member of Employee! void HourlyEmployee::print_check( ) { net_pay = hours * wage_rage; } The parent class member functions must be used to access the private members of the parent

A member function of a class can NOT directly access its own member variable (inherited, private to its base class)! The protected Qualifier protected members of a class appear to be private outside the class, but are directly accessible within a derived classes If member variables name, net_pay, is listed as protected (not private) in the Employee class, this code becomes legal: HourlyEmployee::print_check( ) { net_pay = hours * wage_rage;

access_specifiers_demo.cpp Using protected or not? Using protected members of a class is a convenience to facilitate writing the code of derived classes. Protected members are not necessary Derived classes can use the public methods of their ancestor classes to access private members

Many programming authorities consider it bad style to use protected member variables Overview Inheritance Introduction Three different kinds of inheritance Changing an inherited member function

More Inheritance Details Polymorphism Three different kinds of inheritance Three different ways for classes to inherit from other classes: public, private, and protected. // Inherit from Base publicly class D1: public Base { }; If you do not choose an // Inherit from Base privately inheritance type, C++ defaults class D2: private Base

private inheritance (just like { }; members default to private // Inherit from Base protectedly access if you do not specify class D3: protected Base otherwise). { }; class D4: Base // Defaults to private inheritance { }; to Public inheritance // Inherit from Base publicly class D1: public Base { };

All members keep their original access specifications. Private members stay private, protected members stay protected, and public members stay public. public inheritance Base class access specifier Derived class access specifiier (implicitly given) Directly Directly

accessible in accessible in any member functions other code? of derived class? public public yes yes private private no

no protected protected yes no Private inheritance // Inherit from Base privately class D2: private Base { };

All members from the base class are inherited as private. private members stay private, and protected and public members become private. This does not affect that way that the derived class accesses members inherited from its parent! It only affects the code trying to access those members through the derived class. private inheritance Base class access specifier Derived class access specifiier (implicitly given) Directly accessible in member functions of

derived class? Directly accessible in any other code? public private yes no private private no

no protected private yes no Protected inheritance // Inherit from Base protectedly class D3: protected Base { }; Rarely used. The public and protected members become protected, and private members stay private.

protected inheritance Base class access specifier Derived class access specifiier (implicitly given) Directly accessible Directly accessible in member in any other code? functions of derived class? public protected

yes no private private no no protected protected yes

no Member functions of a derived classes have access to its inherited members based ONLY on the access specifiers of its immediate parent, not affected by the inheritance method used! Base class access specifier for members Derived class access specifiier (implicitly given for inherited members) Directly accessible in member functions of

derived class? Directly accessible in any other code? public inheritance public public yes yes private private

no no protected protected public private yes no private

private no no protected private yes no yes private inheritance no

protected inheritance public protected yes no private private no no

protected protected yes no Overview Inheritance Introduction Three different kinds of inheritance

Changing an inherited member function More Inheritance Details Polymorphism Changing an inherited member function Redefinition of Member Functions When defining a derived class, list

the inherited functions that you wish to change for the derived class The function is declared in the class definition HourlyEmployee and SalariedEmployee each have their own definitions of print_check Next page demonstrates the use of the derived classes defined in HourlyEmployee.h and SalariedEmployee.h. Functions defined in Employee class set_name()

set_ssn() print_check() Functions defined in HourlyEmployee class set_rate() set_hours() print_check() Redefining vs. Overloading A function redefined in a derived class has the same number and type of parameters

The prototype (return value, function name, and parameters) of the function in the derived class must be exactly identical to that in the base class. The derived class has only one function with the same name as the base class An overloaded function has a different number and/or type of parameters than the base class For example, the derived class has two functions with the same name as the base class: one is overloading, one is redefining. void set_name(string first_name, string last_name);//overloading void set_name(string new_name); //redefine A side note: function signatures

An overloaded function has multiple signatures A function signature is the function's name with the sequence of types in the parameter list, not including any const or '&' Some compilers allow overloading based on including const or not including const Change access specifier for an inherited member (data or function)

When re-define a function in a derived class, The re-defined function uses whatever access specifier it is given in the derived class The re-defined function does not inherit the access specifier of the function with the same prototype in the base class. Therefore, You can hide an inherited member (originally public in base class) by specifying it as private You can expose an inherited member (originally protected in base class) by specifying it as public However, you can only change the access specifiers of base members the class are accessible in the derived class. You can never change the access specifier of a base member from private to

protected or public, because derived classes do not have access to private members of the base class. Access to a Redefined Base Function When a function of a base class is redefined in a derived class, the base class function can still be used To specify that you want to use the base class version of the redefined function: int main() { HourlyEmployee sally_h; sally_h.Employee::print_check( );

} Adding new functionality to an inherited member function See derived_changes_inherited_members.cpp file. void Circle::display() { Shape::display(); cout << "Calling Circle's display() ...\n"; } Hide the functionality of an inherited member function Hide the functionality of an inherited member function from any other code.

Redefine the member function (discussed before) Or, give it a new access specifier private when re-defining it in the derived class. Or, simply list it in the private section like this: class Circle : public Shape() { private: See Shape::display; derived_changes_inherited_m //display() is a function defined as public in Shape file embers.cpp without even re-defining it. Expose an inherited member (originally protected in base class)

Read this file derived_exposes_inherited_members.cpp stopped here 4/4. Overview Inheritance Introduction Three different kinds of inheritance Changing an inherited member function

More Inheritance Details Polymorphism More Inheritance Details Some special functions are not inherited by a derived class. They include

The assignment operator Copy constructors Destructors The Assignment Operator In implementing an assignment operator (operator=) in a derived class It is normal to use the assignment operator from the base class in the definition of the derived class's assignment operator Recall that the assignment operator is written as

a member function of a class The Operator = Implementation This code segment shows how to begin the implementation of the = operator for a derived class: Derived& Derived::operator= (const Derived& rhs) { Base::operator=(rhs); /* Base is the name of the parent class This line handles the assignment of the inherited member variables by calling the base class assignment operator The remaining code would assign the member variables introduced in the derived class

*/ Operator = and Derived Classes If a base class has a defined assignment operator = but the derived class does not, then When assigning an object of the derived class to another object of the derived class, C++ will use a default operator that will have nothing to do with the base class assignment operator! Copy Constructors and Derived Classes If a copy constructor is not defined in a

derived class, C++ will generate a default copy constructor This copy constructor copies only the contents of member variables and will not work with pointers and dynamic variables The base class copy constructor will not be used (even if it is defined) The Copy Constructor Implementation of the derived class copy constructor is much like that of the assignment operator: Derived::Derived(const Derived& object) :Base(object), {}

Invoking the base class copy constructor sets up the inherited member variables Since object is of type Derived it is also of type Base Destructors and Derived Classes A destructor is not inherited by a derived class The derived class should define its own destructor

Destructors in Derived Classes If the base class has a programmer-defined destructor, then defining the destructor for the derived class is relatively easy When the destructor for a derived class is called, the destructor for the base class is automatically called The derived class destructor only need to release memory for the dynamic variables added in the derived class Destruction Sequence

If class B is derived from class A and class C is derived from class B When an object of class C goes out of scope The destructor of class C is called Then the destructor of class B Then the destructor of class A Notice that destructors are called in the

reverse order of constructor calls Overview Inheritance Introduction Three different kinds of inheritance Changing an inherited member function More Inheritance Details

Polymorphism Polymorphism Polymorphism Polymorphism refers to the ability to associate multiple definitions with one function declaration using a mechanism called late binding Polymorphism is a key component of the

philosophy of object oriented programming Binding & Early binding Binding The process to convert identifiers (such as variable and function names) into machine language addresses. Early binding (or static binding) An C++ compiler directly associates an identifier name (such as a function or variable name) with a machine address during compilation process. Note that all functions have a unique machine address. When the compiler encounters a function call, it replaces the function call with an instruction that tells the CPU to jump to the address of the function.

Late binding (or dynamic binding) To be discussed very soon A motivating example Imagine a graphics program with several types of figures Each figure may be an object of a different

class, such as a circle, oval, rectangle, etc. Each is a descendant of a class Figure Each has a function draw( ) implemented with code specific to each shape Class Figure has functions common to all figures class Figure public: center() { draw() } draw() Circle public:

draw()//re-defined //center() is inherited c.center(); When a member function is called with a derived class object, the compiler first looks to see if that member exists in the derived class. If not, it begins walking up the inheritance chain and checking whether the member has been defined in any of the inherited classes or the top base class. It uses the first one it finds. Traingle public: draw()//re-defined //center() is inherited int man()

Look at : figure_demo.cpp { Circle c; c.draw(); //which draw() is called? c.center(); //which draw() is called inside center()? } A Problem Class Figure has a function center Function center moves a figure to the center of the screen by erasing the figure and redrawing it in the center of the screen Function center is inherited by each of the derived classes

Function center SHOULD use each derived object's draw function to draw the figure But, Figure class does not know about its derived classes, so how can it know how to invoke a derived object's draw function? Virtual Functions Virtual functions can be used to address the previous problem. Making a function virtual tells the compiler that ...

The programmer doesn't know how the function is implemented when the programmer is defining a base class The programmer wants to wait until the function of an object is used in a program. Only at that time, the implementation of the function is clear, i.e., it is given by the class type of the object. This is called late binding How to use virtual functions? Add keyword virtual to a functions declaration in the base class

virtual is not added to the function definition Define the function differently in a derived class This is the intention of introducing virtual function virtual is not needed for the function declaration in the derived class, but is often included Note that, virtual functions require considerable overhead so excessive use reduces program efficiency figure_demo_virtual.cpp

class Figure void center() { draw() } virtual void draw() Circle virtual void draw()//re-defined //center() is inherited Traingle virtual void draw()//re-defined //center() is inherited Look at : figure_demo_virtual.cpp

int main() { Circle c; c.draw() //which draw() is called? c.center() //which draw() is called inside center()? } Another Example of Virtual Functions As another example, let's design a recordkeeping program for an auto parts store We want to introduce a bill function, and we want a versatile program, but we do not know all the possible types of sales we might have to account for Later we may add mail-order and discount sales

Functions to compute bills will have to be added later when we know what type of sales to add To accommodate the future possibilities, we will make the bill function a virtual function The Sale Class All sales will be derived from the base class Sale The bill function of the Sale class is virtual The Sale class interface and implementation are shown in Display 15.8 Display 15.9

Display 15.8 Sale, DiscountSale DiscountSale::bill Class DiscountSale has its own version of virtual function bill Even though class Sale is already compiled, Sale::savings( ) and Sale::operator< can still use function bill from the DiscountSale class The keyword virtual tells C++ to wait until bill is

used in a program to get the implementation of bill from the calling object Display 15.9 Because function bill is virtual in class Sale, function savings and operator<, defined only in the base class, can in turn use a version of bill found in a derived class When a DiscountSale object calls its savings function, defined only in the base class, function savings calls function bill Because bill is a virtual

function in class Sale, C++ uses the version of bill defined in the object that called savings Sale virtual bill() savings() DiscountSale virtual bill() //no re-defined savings() Q: Since bill() is a virtual function, what will happen in the following code? If bill() is not a virtual function,

what will happen in the following code? Sale simple(10.00); DiscountSale d1(11.0, 10); DiscountSale d2(11.0, 10); if (d1 < simple) { cout << Saving is $ << simple.savings(d1); } if (d1 < d2) { cout << Saving is $ << d2.savings(d1); } Display 15.11

Override vs. Redefine Virtual functions whose definitions are changed in a derived class are said to be overridden Non-virtual functions whose definitions are changed in a derived class are redefined A potential slicing problem if we do not use virtual functions. Stopped here on 4/8/13 Preliminary: C++s Type Checking

C++ carefully checks for type mismatches in the use of values and variables This is referred to as strong type checking Generally, the type of a value assigned to a variable must match the type of the variable Recall that some automatic type casting occurs E.g., double a = Hello; //incorrect.

E.g., int a = 20.34; //correct Strong type checking interferes with the concepts of inheritance Type Checking and Inheritance Consider class Pet { public: virtual void print(); string name; } class Dog : public Pet { public:

virtual void print(); string breed; } Pet print() name Dog print() //overridden name breed Slicing problem: A Sliced Dog is a Pet

C++ allows the following assignments: vdog.name = "Tiny"; vdog.breed = "Great Dane"; vpet = vdog; However, vpet will lose the breed member of vdog since an object of class Pet has no breed member This code would be illegal: cout << vpet.breed; vpet Pet print() name vdog Dog

print() //overridden name breed The Slicing Problem It is legal to assign a derived class object into a base class variable (not a reference), however... This slices off data in the derived class that is not also part of the base class Some member functions and member variables are lost vdog vpet Pet

print() name Dog print() //overridden name breed Extended Type Compatibility It is possible in C++ to avoid the slicing problem Using pointers to dynamic variables and virtual functions, we can still access the added members of the derived class object.

Dynamic Variables and Derived Classes Example: Pet *ppet; void Dog::print( ) Dog *pdog; { pdog = new Dog; cout << "name: " pdog->name = "Tiny"; << name << endl; pdog->breed = "Great cout << "breed: " Dane"; << breed << endl; ppet = pdog;

} ppet->print( ); is legal and produces: name: Tiny breed: Great Dane Display 15.12 (1-2) Display 15.12 (1/2) Display 15.12 (2/2) Use Virtual Functions

The previous example: ppet->print( ); worked because print was declared as a virtual function The following code would still produce an error: cout << "name: " << ppet->name << "breed: " << ppet->breed; //name, breed are public member //but we still cannot use a base class //pointer to DIRECTLY access them //but we can use virtual functions to access them Why? ppet->breed is still illegal because ppet is a pointer to a Pet object that has no breed

member breed is just a data member, not a virtual function! Function print( ) was declared virtual by class Pet When the computer sees ppet->print( ), it checks the virtual table for classes Pet and Dog and finds that ppet points to an object of type Dog Because ppet points to a Dog object, code for Dog::print( ) is used

Remember Two Rules If the domain type of the pointer p_ancestor is a base class for the domain type of pointer p_descendant, the following assignment of pointers is allowed p_ancestor = p_descendant; and we can use p_ancestor and virtual functions to access those data members added only by the derived class (i.e., no data members will be inaccessible) Although all the fields of the p_descendant are there, virtual functions are required to access them

You can NOT directly access an inherited member (even though it is public) A side note on reference (1/3) A reference has to be initialized at the time when declared (except as a function parameter) int x=10; int& y = x; Use references //when & is used in between a type and a variable name, // & specifies the name immediately after it as a reference. // Similarly, double fun1(int & y) cout << &x <

//Here, & does not specify x as a reference cout << &y <

pointer to a variable (or object) ---- can be modified to point to different variables imagine it as an erasable address tag Java reference to a variable---- can be modified to refer to different variables imagine it as an erasable name tag, or a named hat that can be given to different persons to wear More benefits of virtual functions Write code that works for a base class will also work for all of its derived class if virtual functions are used. Examples: function parameters, array of

base class objects Write a newly derived class that will automatically (without modification) work with the existing code that works for the base class. See example program virtual_functions_demo_1.cpp More than two classes in a chain of inheritance hierarchy inheritance hierarchy Animal virtual getClassName() Pet virtual getClassName() Dog

virtual getClassName() Dog d ; Animal &animal_ref = d; cout << animal_ref.GetClassName(); C++ will check every inherited class between Animal and Dog (including Animal and Dog) and use the most-derived version of the function that it finds. virtual_functions_demo_2.cpp Covariant return type virtual_functions_demo_3.cpp //illustrate covariant return type Calling a base classs virtual function virtual_functions_demo_4.cpp

Virtual Destructors Destructors should be made virtual Example: virtual_destructors_demo.cpp Consider Base *pBase = new Derived; delete pBase; If the destructor in Base is virtual, the destructor for Derived

is invoked when pBase points to a Derived object, returning Derived members to the freestore The Derived destructor in turn automatically calls the Base destructor If the Base destructor is not virtual, only the Base destructor is invoked This leaves Derived members, not part of Base, in memory Pure virtual function Consider this situation: We have a function that we want to put in the base class, but we know that only the derived classes know what the function should do. Then, make the function pure virtual virtual_functions_demo_5.cpp

Pure virtual function If a class has a pure virtual function, then the class cannot be instantiated, and the derived classes of the class have to define these function before they can be instantiated. This ensures the derived classes NOT forget to redefine those pure virtual functions (which is what the base class hopes) virtual_functions_demo_5.cpp Revisit Employee class print_check() function should be a pure virtual function in the defn of Employee

class. the original implementation in Employee classs print_check() prints out an error msg is not a good design, as it leaves the problem checking to the run time, not compile time. Design suggestions Simple virtual function Inheriting it implies inherit both interface and a default implementation. In your derive class, you need to support this function, but if you dont want to write your own, you can fall back on the default version in base class. Danger: if a derived class might not want to use

the default implementation from the base class, but forget to define its own, then it will use the inherited one (which is not what it wants!) Design suggestions Pure virtual function Inheriting it implies inherit interface only In your derived class (that can be instantiated), you must define it, but the base class has not idea how you are going to implement it. The danger mentioned for the simple virtual function does not exist.

Design suggestions Regular non-virutal function Dont redefine an inherited nonvirtual function (even though allowed by C++). Make sure the isa relationship always true for public inheritance. class B { public: void fun1(); } class D: public B {public: void fun1(//different implementation);}

//inconsistent, confusing behavior. //same object D, but different fun1() is called, // when D is pointed to by different ptr types // (also true if references used) D d; B *pB=&d; pB ->fun1();// B::fun1() is called!! D *pD=&d; pD ->fun1();//D::fun1() is called!! Interface Class An interface class is a class that

has no members variables, all of the functions are pure virtual! The class is only an interface definition, no actual implementation. Why use interface? When you want to define the functionality that derived classes must implement, but leave the details of how the derived class implements that functionality entirely up to the derived class. virtual_functions_demo_6.cpp

Recently Viewed Presentations

  • Chapter 9, Section I - Cengage Learning

    Chapter 9, Section I - Cengage Learning

    Chapter 12, Annuities Section I Future Value of an Annuity: Ordinary and Annuity Due 12-1 Calculating the future value of an ordinary annuity by using tables. 12-2 Calculating the future value of an annuity due by using tables. 12-3 (Optional)...
  • Lesson 9 - Chapter 9

    Lesson 9 - Chapter 9

    Purchases Transactions:Purchases on Account. Purchases on Account - Credit Purchases. Use Enter Bills tool to record purchase. Use Pay Bills tool to record payment. Journal Entry - Purchase. Supplies. Accounts Payable. Journal Entry - Payment. Accounts Payable. Cash
  • Ch. 10 Moles!

    Ch. 10 Moles!

    Molar Mass. The Mass of 1 mole (in grams) . SAME . as . avg. atomic mass (bottom # in periodic square) Examples: 1 . mole of C atoms = 12.01 g. 1 mole of Mg atoms = 24.31 ....
  • Welcome to 6th Grade Language Arts!

    Welcome to 6th Grade Language Arts!

    Shiloh (P) Reading (cont.) Students will also be required to keep weekly . reading logs. I require 30 minutes per day of independent reading, 15 of which we will complete in class. Students will complete the other 15 minutes at...
  • Introduction to the Cochrane ENT Disorders Group

    Introduction to the Cochrane ENT Disorders Group

    What we do - our reach. In 2010/2011 abstracts and plain language summaries (PLS) of reviews from the Cochrane ENT Disorders group received 80,305 views (74,440 unique views) on the Cochrane Library.
  • 幻灯片 1 - George Mason University

    幻灯片 1 - George Mason University

    Title: 幻灯片 1 Author: Zheng Tianchi Last modified by: gmu Created Date: 12/2/2005 6:37:04 AM Document presentation format: On-screen Show Other titles
  • FTIR FTIROMNIC OMNICSOFTWARE SOFTWARE Gamal A. Hamid Gamal

    FTIR FTIROMNIC OMNICSOFTWARE SOFTWARE Gamal A. Hamid Gamal

    Pane . A pane is an area of the spectral window used to display a spectrum along with associated information and software features. A spectral window can contain one or several panes, as specified by Display Setup and the Window...
  • Annual Enrollment - UAMS

    Annual Enrollment - UAMS

    Must be enrolled as a student (or a dependent of a student) in the institution. Offering dependent coverage is determined by the university. Does not condition eligibility for the health insurance coverage on any health status. Meets any additional requirements...