1 / 28

Inheritance Basics and Polymorphism in C++

This chapter covers the basics of inheritance in C++, including IS-A relationships, polymorphism, access modifiers, static vs dynamic binding, constructors and copy assignment operators, abstract classes, and other tricky details.

egoodson
Download Presentation

Inheritance Basics and Polymorphism in C++

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Chapter 4Inheritance Saurav Karmakar Spring 2007

  2. Objective • IS-A relationships and the allowable changes for derived classes • The concept of polymorphism • Public, private, and protected members and inheritance • Static vs. dynamic binding • Default constructor, copy constructor, and copy assignment operator • Abstract classes • Tricky stuff

  3. 4.1 What is Inheritance? • Another mechanism for code reuse. • A process of deriving classes from a base class w/o disturbing the implementation of the base class. • Ex: Vehicleis a class Car is a Vehicle => Car derived from Vehicle

  4. Figure 4.2 istringstream istream fstream ifstream IOS iostream stringstream ostream ostringstream ofstream

  5. Polymorphism • Variables can reference objects of several type. When operation are applied to the variable, the operation appropriate to the referenced object is automatically selected. • Derived class is a new class which inherits all public & protected properties of a base class. • Derived class is type-compatible with its base class.

  6. 4.2 Inheritance Basics • Public inheritance: all public members of the base class remain public in the derived class =>models IS-A relationship =>mostly used. • Private inheritance: all the public members of the base class remain hidden => models HAS-A relationship.

  7. General layout of public inheritance class Derived : public Base { //any member are not listed are inherited //except constructor, destructor, copy, constructor and operator= public: //new constructor and destructor if necessary //modify base member function //new function private: //new data member or private function //base members should be disable };

  8. Inheritance cont. . . • Derived class inherits all member functions from the base class. It may accept, disallow, or redefine them. • Derived class can define new functions.

  9. Inheritence … Ways to Implement • Public access to a base class allows access to other classes in addition to derived classes. • Protected Class member is is private to every class except a derived class.

  10. Access rules

  11. Constructor and Base class initialization • If there is no constructor in a derived class, a default zero-parameter constructor will be generated • Base class constructors can be explicitly called by name in the initializer list. • Default constructor for a derived class Derived() : Base() {}

  12. Constructor for the new exception class Underflow class Underflow : public underflow_error { public: underflow(const string & msg =“ “) : underflow_error(msg.c_str()) {} };

  13. Overriding a method(member function) • Overriding base class methods: Derived class methods must have the same signature and compatible return types with the base class methods. • Partial overriding: overriding base class methods by adding more functionality.

  14. Example of partial overriding class Workaholic : public Worker { public: void doWork() //overriding base method { Worker::doWork();// call base method drinkCoffee(); // new method Worker::doWork();// call base method } };

  15. Bindings • Static binding: the decision about which function/type to use to resolve an overload is made at compile time. • Dynamic binding: the decision must be made at run time.

  16. Worker w; Workaholic wh; . . . w.doWork(); wh.doWork(); figure 4.8 static binding Worker *wptr; cin>>x; if(x != 0) wptr = new Workaholic(); else wptr = new Worker(); . . . //which doWork is used ? wptr -> doWork(); Figure 4.9 dynamic binding Examples

  17. Virtual • If a function is redefined in a derived class, and the overloading is resolved in run time, it should be declared virtualin the base class. • Example: class Worker{ public: virtual void doWork(); };

  18. Virtual Cont… • Constructors are “NEVER” virtual • Destructors should be virtual for base class => Let the computer know which one to call for deallocation.

  19. Abstract • Abstract method, pure virtual function, has no meaningful definition in the base class and is defined in derived classes. • Abstract class: a class containing any abstract method = > can’t be instantiated and must be inherited. • Example: shape class

  20. The abstract base class shape class Shape { public: Shape( const string & shapeName = "" ) : name( shapeName ) { } virtual ~Shape( ) { } virtual double area( ) const = 0; //abstract method bool operator< ( const Shape & rhs ) const { return area( ) < rhs.area( ); } virtual void print( ostream & out = cout const { out << name << " of area "<< area( ); } private: string name; }; //figure 4.13

  21. General Rules • Nonvirtual functions: Overloading is resolved at compile time. • Virtual functions: Overloading is resolved at run-time (Base class provide a default implementation) • Pure virtual functions: Overloading is resolved at run-time. (Base class provide no default implementation)

  22. 4.4 Tricky C++ Details • Changing the default value in a derived class is unsafe because doing so can create an inconsistency with virtual functions.

  23. Cont… • When a method is declared in a derived class, it “hides” all methods of the same name in the base class => get away by partial overriding or using “using” directive

  24. Illustration of hiding class Base{ public: virtual void bar(); }; class Derived{ public: void bar(int x); }; Void test( Base & arg1, Derived & arg2){ arg1.bar(); // call Base::bar() => OK arg1.bar(4); //call Base::bar(int) => fails for not arg2.bar(4); // call Derived::bar(int) => OK arg2.bar(); // fails b/c Derived::bar(int) has hidden Base::bar() }

  25. Two ways to solve Hiding • Override the zero-parameter bar in Derived: void bar() {Base::bar();} • Use keyword “using” in derived class: using Base::bar;

  26. 4.5 Multiple Inheritance • A mechanism for deriving a class from several base classes. Ex: Student and Employee are derived classes of UniversityPerson. class Student: virtual public UniversityPerson(){. . . }; class Employee:virtual public UniversityPerson(){…}; class StudentEmployee : public Student, public Employee{. . .};

  27. Common errors (page 151) • Inheritance is private by default. A common error is to omit the keyword public, which is needed to specify public inheritance. • Objects of abstract classes can NEVER be initiated. • Constructors can never be declared virtual. • More errors defined in page 151..

  28. Summary • Inheritance: a powerful way for code reuse • Virtual: Dynamic binding, binding at execution time. • Abstract: must be defined in derived classes. Abstract classes can’t be instantiated.

More Related