10/15/2009

Public Inheritance
• Used to denote an IS-A relationship
• If derived class D publicly inherits from
C++ Inheritance base class B, then every object of D can
be used wherever a B may be used, but
not visa-versa.
Chapter 6
• Syntax: class D : public B
• Math can trip you up
– Is a square a rectangle?

Is it an IS-A ? Inheritance is a Union

class Bird { class Bird { • The derived class gets the data members
public : fly(); }; of the base class (not necessarily visible)
};
• The derived class may add more data
class Penguin : public Bird { class FlyingBird() : public Bird {
members (sizeof object increases)
public: void fly(); ??? public: void fly();
} };
• The derived class inherits the public
methods of the base class
class Penguin : public Bird { • The derived class may override inherited
}; methods and/or add new ones
• Implication: no array of base class

1
 10/15/2009

Simple Example C++ Dispatch != Java Dispatch

class Animal {
void speak() {“can’t speak”} Animal a; a.speak(); • Java dispatch is always dynamic
};
class Dog : public Animal { Dog d; d.speak()
• C++ dispatch defaults to static
void speak() { “woof” } • Dynamic dispatch
};
class Cat : public Animal { Cat c; c.speak();
– determine actual method at runtime
void speak() { “meow” } – What are the implications?
};
Class Pig : public Animal { Pig p; p.speak();
• Static dispatch
void speak() {“oink” } – determine method at compile time
};
class DebateClub {
bool tryout (const Amimal& a) { a.speak() } ???
}

C++ Static Dispatch C++ Dynamic Dispatch

• Just a normal function call • Compiler sees a.speak()
• Compiler sees a.speak() • If we want to have dynamic dispatch, compiler
must generate code like:
– finds the function
– Find the function named “speak”
– generates code to call it (e.g. jsr speak) – Invoke it (i.e. dispatch)
– linker will actually resolve address • Where is this lookup table stored?
– each class has a table of virtual functions
• How is it referenced?
– each object of class has a pointer (vptr) to table

2
 10/15/2009

Function Lookup Implications of Dynamic Dispatch

• Can’t just have has table of name/address • Object size grows by sizeof(vptr)
(why not?) • Invoking a function requires extra lookup
• Furthermore, operator+ is not a legal code (space and time)
function name!
• C++ made static dispatch the norm
• Compiler does name mangling to give
every function a “unique” name because of efficiency concerns.
• G++ translates
– std::string article:: format(void) to
– _ZN9wikipedia7article8formatEV

Specifying Dynamic Dispatch C++ equivalent of super

• Use the C++ keyword virtual to mark member • Use the scope resolution operator ::
functions that should have dynamic dispatch
• Derived class D has a function foo() that
• Done on a function by function basis overrides foo() in the base class B.
• General rules:
• For D’s foo() to call B’s foo() write
– If the intent is that a member function may be
overridden, mark it virtual and it will be virtual for all B::foo()
derived classes • D’s constructor can access B’s constructor
– If any function virtual, destructor should be virtual
in the initialization list by B(parameters)
– Don’t override methods that aren’t declared virtual
– Don’t call virtual methods in constructors, destructors

3
 10/15/2009

Non Virtual. Virtual, and Pure

Pure Virtual Functions
Virtual Functions
• A virtual function whose declaration is • Specifies what you want to inherit
followed by = 0 • Non virtual: you inherit interface and a
• Declare as: virtual foo(parameter list) = 0; mandatory implementation (i.e. you should
not override)
• A class with at least one pure virtual
• Virtual: you inherit an interface and a
function is like a Java abstract class default implementation which you may
• A class with nothing but pure virtual override.
functions is like a Java interface • Pure virtual: you inherit an interface and
you must supply an implementation.

Inherited Names may be Hidden Separate Interface/Implementation

Class Base { • The interface of a function is its name,
void mf1(); parameter list and return type
void mf1(int); // overloaded name
void mf3();
• The implementation of a function is the
}; code that defines how the function works.
Class Derived : public Base { • There is often a default implementation
void mf1(int); // overrides base method
that is put in the base class.
void mf4();
} • Can prevent problems by separating (see
Base b; b.mf1(); b.mf1(3); b.mf3(); b.mf4(); Effective C++ by Scott Meyers)
Derived d; d.mf1(5); d.mf3(); d.mf4(); d.mf1();

4
 10/15/2009

Airports and Airplanes Alternate Design

class Airport { … }
class Airplane { class Airport { … }
class Airplane {
public: public: virtual void fly (const Airport& destination) = 0; // an interface!
virtual void fly (const Airport& destination); protected : flyJet(const Airport& destination);
};
}; void Airplane::flyJet (const Airport& destination) {
void Airplane::fly (const Airport& destination) { // default code for flying a jet
};
// default implementation of flying
}; class Boeing : public Airplane {
public virtual void fly (const Airport& destination) { flyJet(destination); }
class Boeing : public Airplane { … }; // doesn’t override fly };
class Airbus : public Airplane { … }; // doesn’t override fly
class Airbus : public Airplane {
Class Glider : public Airplane { .. }; // doesn’t override fly – what is result? public virtual void fly (const Airport& destination) { flyJet(destination); }
};

Class Glider : public Airplane { .. }; // forced to override fly()

Private Inheritance Multiple Inheritance

• Used to model a HAS-A, or • C++ allows class to inherit from more that
CAN_BE_IMPLEMENTED_WITH one parent
• Substitute private for public in declaration • May be used the way Java interfaces are
• Nothing from base class visible from used (i.e. implement multiple interfaces) if
derived class. the classes are pure virtual classes
• Purely an implementation technique. Base • May also be used to inherit from multiple
class provides most of what you need and
a lot you don’t need and don’t want concrete classes
exposed. • Syntax class Foobar : public Foo, public Bar

5
 10/15/2009

Interesting issues Slicing

• Recall that inheritance is a union. So, if a class
inherits from multiple classes, just union them all • Occurs when a derived type is assigned to a
together. base type (e.g. in operator =)
• What happens if parent classes have identical • Derived class generally contains additional data
data members or functions? members, thus its size is bigger.
– Multiple copies of everything?
• Memory layout is data member of base, followed
– Can have virtual inheritance! by data members of derived classes.
– How to distinguish which one you want?
• Slicing cuts off derived class data members
– Scope resolution operator :: can help
• What about virtual functions?
• Multiple inheritance often is a graph rather than
a tree
• Ask Dr Draper!

Casting down the chain Factories and Singletons

• In Java one can: Dog d = (Dog)Animal; • A Factory is a function that returns
– A ClassCastException is thrown if the cast different sub classes based on input
fails • Return value is generally a pointer to the
• C++ provides a similar mechanism with base class object. Because of virtual
dynamic_cast<> methods, the object behaves correctly.
– Dog* d = dynamic_cast<Dog *>animalPtr • Singleton is a class that has one and only
– The returned value is null if the cast fails one instance. How is this accomplished?

6
 10/15/2009

Member vs non-member functions Summary

• Object Oriented tells us to collect data and • Inheritance is an IS-A relationship
functions together.
• But, another goal of OO is encapsulation (i.e. • C++ provides both static/dynamic dispatch
information hiding) • Destructor should be virtual if any
• These conflict in the member/non-member functions are virtual.
decision.
• Slicing forces access to polymorphic
• So, if something can be done without direct
access to object’s data, you may prefer non- objects via pointers or references
member function. These are often “convenience” • C++ interfaces are classes with only pure
functions. Can be separated from class itself.
virtual functions