cmsc 202 n.
Skip this Video
Loading SlideShow in 5 Seconds..
CMSC 202 PowerPoint Presentation
Download Presentation
CMSC 202

Loading in 2 Seconds...

play fullscreen
1 / 30

CMSC 202 - PowerPoint PPT Presentation

  • Uploaded on

CMSC 202. Polymorphism. Inheritance and Polymorphism. Inheritance allows us to define a family of classes that share a common interface. Polymorphism allows us to manipulate objects of these classes in a type-independent way.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'CMSC 202' - fathi

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
cmsc 202

CMSC 202


inheritance and polymorphism
Inheritance and Polymorphism
  • Inheritance allows us to define a family of classes that share a common interface.
  • Polymorphism allows us to manipulate objects of these classes in a type-independent way.
  • We program the common interface through a pointer or reference to an (abstract) base class. The actual operation to invoke is not determined until run-time based on the specific type of object actually addressed.
c and polymorphism
C++ and Polymorphism
  • Polymorphism is the ability of a base class pointer (or reference) to refer transparently to any of its derived classes.
  • Polymorphism (and dynamic binding) are supported only when we use pointers (or references)
inheritance and pointers
Inheritance and Pointers
  • A base class pointer can point to an object of a derived class
    • Derived class object “is-a” base class object
    • But can’t use pointer to call methods only defined in the derived class.
  • A derived class pointer CANNOT point to the base class
    • The base class doesn’t have any of the extensions provided by the derived class
static vs dynamic binding
Static vs. Dynamic Binding
  • Binding
  • The determination of which method in the class
  • hierarchy is to be invoked for a particular object.
  • Static (Early) Binding occurs at compile time
  • When the compiler can determine which method in the
  • class hierarchy to use for a particular object.
  • Dynamic (Late) Binding occurs at run time
  • When the determination of which method in the class
  • hierarchy to use for a particular object occurs during
  • program execution.
static binding
Static Binding
  • For example,
  • Time t1;
  • ExtTime et2;
  • t1.setTime(12, 30, 00); // static binding
  • et1.setExtTime(13, 45, 30); // static binding
  • t1.printTime( ); // static binding – Time’s printTime( )
  • et1.printTime(); // static binding – ExtTime’s printTime( )
dynamic binding
Dynamic Binding
  • Compiler cannot determine binding of object to method
  • Binding is determined dynamically at runtime
  • To indicate that a method is to be bound dynamically, the base class must use the reserved word virtual
  • When a method is defined as virtual, all overriding methods from that point on down the hierarchy are virtual, even if not explicitly defined to be so
a common example
A common example

class Shape { public: virtual void draw ( ) const = 0; // pure virtual virtual void error ( ); // virtual void objectID ( ); // non virtual};

void Shape::error ( ){ cerr << “Shape error” << endl;}void objectID ( ){ cout << “a shape” << endl;}


class Circle : public Shape{ public: virtual void draw( ) const; // method for drawing a circle virtual void error ( ); // overriding Shape::error …

};void Circle::draw ( ) const{ // code for drawing a circle}void Circle::error ( ) { cout << “Circle error” << endl;}


class Rectangle : public Shape{ public: virtual void draw( ) const; // method for drawing a rectangle …};void Rectangle::draw ( ) const{ // code to draw a rectangle}


Now consider these pointers: Shape *pShape; Circle *pCircle = new Circle; Rectangle *pRectangle = new Rectangle;Each pointer has static type based on the way it’s defined in the program text.

The pointer’s dynamic type is determined by the type of object to which they currently refer.

pShape = pCircle; // pShape’s dynamic type is now Circle pShape->draw( ); // calls Circle::draw and draws a circle pShape = pRectangle; // pShape’s dynamic type is Rectangle pShape->draw ( ); // calls Rectangle::draw

an array of base class pointers
An array of base class pointers

Shape *shapes[3];

shapes[0] = new Circle;

shapes[1] = new Rectangle;

shapes[2] = new Triangle;

for (int s = 0; s < 3; s++)shapes[s]->draw( );

a linked list of base class pointers
A linked list of base class pointers

LinkedList<Shape * > shapes;

shapes.insert (new Circle);

shapes.insert (new Rectangle);

shapes.insert (new Triangle);

// traverse the list, printing each Shape in list






A simple ANIMAL hierarchy


class Animal { public: Animal ( ) {name = “no name”, nrLegs = 0;} Animal ( string s, int L) : name (s), nrLegs(L) { } virtual ~Animal ( ); virtual void speak ( ) const { cout << “Hi, Bob”; } string getName (void) const { return name; } void setName (string s) { name = s; } void setNrLegs (int legs) { nrLegs = legs;} int getNrLegs ( void ) const { return nrLegs;} private: string name; int nrLegs;};


class Dog : public Animal{

public: Dog ( ) : Animal (“dog”, 4), breed (“dog”) { } Dog (string s1, strings2) : Animal (s1, 4), breed (s2) { } ~Dog ( ); void setBreed (string s1) { breed = s1; } string getBreed (void ) const { return breed;} void speak ( ) const { cout << “Bow Wow ”; } void speak (int n) const { for (int j = 0; j < n: j++) speak ( ); } . . . . . . private: string breed;



class Whale : public Animal{

public: Whale ( ); ~Whale ( ); private:};


main ( ) { Animal anAnimal (“Homer”, 2); Dog aDog (“Fido”, “mixed”); Whale aWhale (“Orka”); anAnimal.speak( ); aDog.speak( ); aDog.speak( 4 ); aWhale.speak( ) ; Animal *zoo[ 3 ]; zoo[0] = new Whale; zoo[1] = new Animal; zoo[2] = new Dog (“Max”, “Terrier”); for (int a = 0; a < 3; a++) { cout << zoo[a]->getName( ) << “ says: “ zoo[a] -> speak( ); }}

works for functions too
Works for functions too
  • Perhaps the most important use of polymorphism is the writing of functions to deal with all classes in the inheritance hierarchy. This is accomplished by defining the function parameters as pointers (or references) to base class objects, then having the caller pass in a pointer (or reference) to a derived class object. Dynamic binding calls the appropriate method.
  • These functions are often referred to as “polymorphic” functions.
drawshape with a pointer
drawShape( ) with a pointer

void drawShape ( Shape *sp){ cout << “I am “ ; sp -> objectID ( ); sp -> draw ( ); if (something bad) sp->error ( );


What is the output if drawShape( ) is passed a pointer to a Circle? a pointer to a Rectangle?

drawshape via reference
drawShape ( ) via reference

void drawShape ( Shape& shape){ cout << “I am “ ; shape.objectID ( ); shape.draw ( ); if (something bad) shape.error ( );


What is the output if drawShape is passed a reference to a Circle? a reference to a Rectangle?

calling virtual methods from within other methods
Calling virtual methods from within other methods
  • Suppose virtual drawMe( ) is added to Shape and inherited by Rectangle without being overridden.

void Shape::drawMe ( void)


cout << “drawing: “ << endl; draw( );


which draw gets called
Which draw( ) gets called

From within drawMe( ) with this code?

Rectangle r1;

r1.drawMe ( );

The Rectangle version of draw( ), even though drawMe( ) was only defined in Shape. Why?

Because inside of drawMe( ), the call to draw( ) is really this->draw ( ); and since a pointer is used, we get the desired polymorphic behavior.

don t redefine objectid
Don’t redefine objectID( )

Note that neither Circle nor Rectangle redefined the objectID( ) method which was a nonvirtual function. But what if they had?

Suppose the Rectangle class had it’s own version of objectID().Consider this code: Rectangle R; // a Rectangle object Shape *pS = &R; // base class pointer to a Rectangle Rectangle *pR = &R; // derived class pointer to a Rectanglewhat is the output of the following? pS -> objectID ( ); pR -> objectID ( );

Bottom Line – don’t override nonvirtual functions

old code and new code
Old code and new code
  • In the procedural world (like that of C), it’s easy for new code to call old code using functions. However, it’s difficult for old code to call new code unless it’s modified to know about the new code.
  • In the OO world, old code (polymorphic functions) can dynamically bind to new code. This occurs when a new derived class is passed (by pointer or reference) to the polymorphic function. The polymorphic function needs no modification.
don t pass by value
Don’t Pass by Value

A function which has a base class parameter passed by value should only be used with base class objects – for two reasons

  • The function isn’t polymorphic. Polymorphism only occurs with parameters passed by pointer or reference
  • Even though a derived class object can be passed to such a function (a D is-a B), none of the derived class methods or data members can be used in that function. This is a phenomenon called “member slicing”.
the same is true for assignment
The same is true for assignment

Time t(10, 5, 0);

ExtTime et(20, 15, 10, ExtTime::EST);

  • A derived class object can be assigned to a base class


t = et; // legal, BUT Member slicing occurs.

  • A base class object cannot be assigned to a derived class


et = t; // illegal! Not all data members can be filled

polymorphism and destructors
Polymorphism and Destructors
  • A problem – if an object (with a non-virtual destructor) is explicitly destroyed by applying the delete operator to a base class pointer, the base class destructor is invoked. Circle C; Shape *sp = &C; delete sp; // calls Shape’s destructor // if the destructor is not // virtual
  • So what ??
polymorphism and destructors1
Polymorphism and Destructors
  • Solution -- Declare a virtual destructor for any base class with at least one virtual function.
  • Then, when the derived class’s destructor is invoked, the base class destructor will also be invoked automatically
designing a base class with inheritance and polymorphism in mind
Designing A Base Class with Inheritance and Polymorphismin mind

For the base class

  • Identify the set of operations common to all the children
  • Identify which operations are type-independent (these become (pure) virtual to be overridden in derived classes)
  • Identify the access level (public, private, protected) of each operation

For a more complete discussion, see “Essential C++”, Stanley Lippman (section 5.4)