Polymorphism Tiziana Ligorio 1 Todays Plan Inheritance Recap - PowerPoint PPT Presentation

Polymorphism Tiziana Ligorio � 1

Today’s Plan Inheritance Recap Polymorphism � 2

Announcements Q: Why use dynamic memory allocation? 
 � 3

Inheritance Recap � 4


 Basic Inheritance class Printer 
 { 
 public: 
 //Constructor, destructor 
 void setPaperSize(const int size); 
 void setOrientation(const string& orientation); 
 void changeCartridge(); 
 void printDocument(const string& document); 
 private: 
 // stuff here 
 }; //end Printer class BatchPrinter: public Printer // inherit from printer 
 { 
 public: 
 //Constructor, destructor 
 void addDocument(const string& document); 
 void printAllDocuments(); 
 private: 
 vector<string> documents; //Document queue 
 }; //end BatchPrinter � 5


 class GraphicsPrinter: public Printer // inherit from printer 
 { 
 public: 
 //Constructor, destructor 
 void changeCartridge(); 
 void printDocument(const Picture& picture); 
 private: 
 //stuff here 
 }; //end GraphicsPrinter � 6

Basic Inheritance Base class Superclass is-a is-a Derived Classes Subclasses void initializePrinter(Printer& p) 
 BatchPrinter batch; 
 initizlizePrinter(batch); //legal because batch is-a printer Think of argument types as specifying minimum requirements � 7

Problem class BatchPrinter: public Printer // inherit from printer 
 { 
 public: 
 Can’t store different //Constructor, destructor 
 types of documents in void addDocument(const string& document); 
 printer queue void printAllDocuments(); 
 private: 
 vector<string> documents; //Document queue 
 }; //end BatchPrinter We would like to print all kinds of documents not just text 
 documents should be able to store di ff erent types of documents � 8


 Generalized Document Whatever the type of document, a printer ultimately prints a grid of pixels Generalized Document should know how to convert itself into a printable format 
 We want Document to be an interface => not concerned with implementation details � 9

printAllDocuments() Document Document Document Document Document::convertToPixelArray() 
 printPixelArray() � 10

Polymorphism � 11

class BatchPrinter: public Printer // inherit from printer 
 { 
 public: 
 //Constructor, destructor 
 void addDocument(const Document* document); 
 void printAllDocuments(); 
 private: 
 vector<Document*> documents; //Document queue 
 }; //end BatchPrinter � 12


 Abstract Class! This function has no implementation** class Document: 
 { 
 public: 
 //Constructor, destructor 
 virtual void convertToPixelArray() const = 0 ; 
 virtual int getPriority() const = 0 ; 
 private: 
 //stuff here 
 }; //end Document I’ll explain this next **odd syntax due to historical/political reasons, explained in quote later � 13


 class TextDocument: public Document// inherit from Document 
 { 
 public: 
 //Constructor, destructor 
 virtual void convertToPixelArray() const override; 
 virtual int getPriority() const override; 
 void setFont(const string& font); //text-specific formatting 
 void setSize(int size); private: 
 //stuff here 
 }; //end TextDocument Have implementation � 14

class TextDocument: public Document class GraphicsDocument: public Document class PortableFormatDocument: public Document class SpreadsheetDocument: public Document � 15

GraphicsDocume TextDocument TextDocument MySpecialDocument But how does compiler know whose convertToPixelArray() to call? TextDocument::convertToPixelArray? 
 GraphicsDocument::convertToPixelArray? � 16

Where are we going? I want to store all kinds of documents in my BatchPrinter queue I want to access the correct convertToPixelArray() method specific to each different document type � 17


 
 main() TextDocument is-a Document GraphicsDocument is-a Document We can point to objects of derived class using pointers to base class BatchPrinter myBatchPrinter; Document* myTextDocument = new TextDocument; 
 Document* myGraphicsDocument = new GraphicsDocument; 
 We store in printer queue pointers to Document //do stuff but really can access any derived class document myBatchPrinter.addDocument(myTextDocument) 
 myBatchPrinter.addDocument(myGraphicsDocument) myBatchPrinter.printAllDocuments(); 
 myTextDocument->convertToPixelArray(); 
 myGraphicsDocument->convertToPixelArray(); convertToPixelArray is marked virtual so the appropriate function call is determined at runtime � 18

Late Binding via Virtual Functions Avoid statically binding function calls at compile time Must declare functions as virtual for late binding � 19

Polymorphism We just saw an example of polymorphism (literally many forms) With virtual functions the outcome of an operation is determined at execution time With basic inheritance we were just saving ourselves the trouble of re-writing code � 20

Abstract Class Pure virtual function ( =0 ) has no implementation 
 Abstract class 
 - Has at least one pure virtual function 
 - Cannot be instantiated because does not have 
 implementation for some/all its member functions Document myDocument; //Error! 
 Document* myDocument = new Document;//Error! � 21

“The curious =0 syntax was chosen over the obvious alternative of introducing a new keyword pure or abstract because at the time I saw no chance of getting a new keyword accepted. Had I suggested pure , Release 2.0 would have shipped without abstract classes, I chose abstract classes. Rather than risking delay and incurring the certain fights over pure , I used the traditional C and C++ convention of using 0 to represent ‘not there’ ” Bjarne Stroustrup � 22


 
 
 
 
 
 Recap Basic Inheritance Base Derived main() someMethod(); someMethod() override; . . . . . . Base base_object; 
 Derived derived_object; 
 // stuff here base_object.someMethod(); //calls Base function 
 derived_object.someMethod(); // calls Derived function - Overriding!!! 
 � 23


 
 
 
 
 
 Recap Polymorphism Base Derived main() someMethod(); someMethod() override; . . . . . . Base* base_ptr = new Base; 
 Base* derived_ptr = new Derived; 
 // stuff here base_ptr->someMethod(); //calls Base function 
 derived_ptr->someMethod(); // ??? 
 � 24


 
 
 
 
 
 Recap Polymorphism Base Derived main() someMethod(); someMethod() override; . . . . . . Base* base_ptr = new Base; 
 Base* derived_ptr = new Derived; 
 // stuff here base_ptr->someMethod(); // calls Base function 
 derived_ptr->someMethod(); // calls Base function 
 � 25


 
 
 
 
 
 Recap Polymorphism Base Derived main() virtual someMethod(); someMethod() override; . . . . . . Base* base_ptr = new Base; 
 Base* derived_ptr = new Derived; 
 // stuff here base_ptr->someMethod(); //calls Base function 
 derived_ptr->someMethod(); // call Derived function - LATE BINDING!!!! 
 � 26


 Recap Abstract Class This function has no implementation** class Document: 
 { 
 public: 
 //Constructor, destructor 
 virtual void convertToPixelArray() const = 0 ; 
 virtual int getPriority() const = 0 ; 
 private: 
 //stuff here 
 }; //end Document � 27

Polymorphism without abstraction Superclass need not be abstract Virtual functions in superclass need not be pure virtual � 28


 
 
 
 
 
 Polymorphism without Abstract Classes class Skater 
 class InexperiencedSkater: { 
 public Skater 
 public: 
 { 
 //constructor, destructor 
 public: 
 virtual void slowDown(); 
 //constructor, destructor 
 //virtual, not pure 
 virtual void slowDown() override; 
 private: 
 private: 
 //stuff here 
 //stuff here 
 }; //end InexperiencedSkater 
 }; //end Skater void InexperiencedSkater::slowDown() 
 { 
 void Skater::slowDown() fallDown(); 
 { 
 implementation does not } //end slowDown applyBreaks(); 
 have virtual or } //end slowDown override keyword � 29

Polymorphism without Abstract Classes main() Skater* firstSkater = new Skater; 
 firstSkater->slowDown(); // applyBreaks() Skater* secondSkater = new InexperiencedSkater; 
 secondSkater->slowDown(); // fallDown() - LATE BINDING! � 30


 
 
 
 
 
 Polymorphism without Abstract Classes Need not override non-pure virtual functions class StuntSkater: public Skater 
 { 
 public: 
 //constructor, destructor - note no mention of slowDown 
 void frontFlip(); void backFlip(); private: 
 //stuff here 
 }; //end StuntSkater 
 // stuff here 
 Skater* stunt_skater = new StuntSkater; 
 stunt_skater->slowDown(); // applyBreaks() � 31


 
 
 Warning When using pointers to base class NotVirtual 
 class, to let derived classes { 
 override functions in base public: 
 class must make the base void notAVirtualFunction(); 
 class’s function virtual }; //end NotVirtual class NotVirtualDerived: public NotVirtual 
 { 
 public: 
 void notAVirtualFunction() override; 
 }; //end NotVirtualDerived 
 NotVirtual* nv = new NotVirtualDerived; 
 nv->notAVirtualFunction(); // OUCH!!! calls NotVirtual’s member 
 // instead of NotVirtualDerived’s member � 32