Static Binding Static binding chooses the function in the class of the base class pointer, ignoring any versions in the class of the object actually pointed to Static binding is done at compile time

Late Binding / Dynamic Binding technique of waiting until runtime to determine which version of a member function is appropriate Can look at the actual class of the object pointed to and choose the most specific version of the function Dynamic binding is used to bind virtual functions

Polymorphism Polymorphism is another word for late binding. Enables us to write programs that process objects of classes that are part of the same class hierarchy as if they were all objects of the hierarchy’s base class.

Virtual Functions (C++ only) By default, C++ matches a function call with the correct function definition at compile time -- static binding. Can specify that the compiler match a function call with the correct function definition at run time -- dynamic binding. Declare a function with the keyword virtual if you want the compiler to use dynamic binding for that specific function.

Virtual Functions (C++ only) The virtual function specification tells the compiler to create a pointer to a function f(), but to not fill in the value of the pointer until the function is actually called. Declaring a function virtual will make the compiler check the type of each object to see if it defines a more specific version of the virtual function;

Virtual Functions (C++ only) the compiler chooses the appropriate definition of f(), not by the type of reference, but by the type of object that the reference refers to. Therefore, a virtual function is a member function you may redefine for other derived classes, and can ensure that the compiler will call the redefined virtual function for an object of the corresponding derived class, even if you call that function with a pointer or reference to a base class of the object.

Virtual Functions (C++ only) To create a virtual function, place the keyword virtual before the function's return type in the declaration section. Once a function is declared as virtual, it remains virtual for the next derived class with or without a virtual declaration in the derived class. The virtual declaration in the derived class is not needed, but is usually included both for clarity and to ensure that any subsequently derived classes correctly inherit the function.

Virtual Functions (C++ only) A class that declares or inherits a virtual function is called a polymorphic class. You redefine a virtual member function, like any member function, in any derived class.

Polymorphism and Virtual Member Functions Polymorphic code: Code that behaves differently when it acts on objects of different types Virtual Member Function: The C++ mechanism for achieving polymorphism

Polymorphism Consider the Vehicle, Car, Truck hierarchy where each class has its own version of the member function printType( ) Vehicle Car Truck 18-Wheeler

Polymorphism class Vehicle { public: Vehicle(); Vehicle(…); void printType(); private: string type; };

Polymorphism class Car : public Vehicle { public: Car(); Car(…) void printType(); … };

Polymorphism class Truck : public Vehicle { public: Truck(); Truck(…) void printType(); … };

void Vehicle::printType() { cout << "vehicle"; } Polymorphism void Vehicle::printType() { cout << "vehicle"; }

void Car::printType() { cout << "car"; } Polymorphism void Car::printType() { cout << "car"; }

void Truck::printType() { cout << "truck"; } Polymorphism void Truck::printType() { cout << "truck"; }

Polymorphism Consider the collection of different Vehicle objects Vehicle *vehCollection[] = {new Vehicle, new Car,new Truck}; and accompanying code for(int k=0; k<3; k++) vehCollection[k]->printType(); Prints: vehicle vehicle vehicle ignoring the more specific versions of printType() in Car and Truck See inheritance4.h and pr15-02.cpp

Polymorphism The preceding code is not polymorphic: it behaves the same way even though Vehicle, Car, and Truck have different types and different printType() member functions. Static binding is used. In the expression vehCollection[k]->printType(); the compiler sees only the type of the pointer vehCollection[k], which is pointer to Vehicle; it does not see the type of the actual object pointed to, which may be Vehicle, or Car, or Truck

Polymorphism Polymorphic code would have printed vehicle car truck instead of vehicle vehicle vehicle

Virtual Functions If the member functions printType()are declared virtual, then the code Vehicle *vehCollection[] = {new Vehicle, new Car,new Truck}; for(int k=0; k<3; k++) vehCollection[k]->id(); will print vehicle car truck See inheritance5.h and pr15-03.cpp

Virtual Functions Declaring printType() as a virtual function class Vehicle { public: … virtual void printType(); }

Virtual Functions Declaring printType() as a virtual function: class Car : public Vehicle { … virtual void printType(); }

Virtual Functions Declaring printType() as a virtual function: class Truck : public Vehicle { … virtual void printType(); }

Virtual functions Now that printType() is declared virtual, vehCollection[k]->printType() will print vehicle car truck dynamic binding is used and the compiler chooses the appropriate definition of printType() by the type of object that the reference refers to.

Abstract Base Classes and Pure Virtual Functions An abstract class is a class that contains no objects that are not members of subclasses (derived classes) For example, in real life, Animal is an abstract class: there are no animals that are not dogs, or cats, or lions …

Abstract Base Classes and Pure Virtual Functions Abstract classes are an organizational tool. They are useful in organizing inheritance hierarchies Abstract classes can be used to specify an interface that must be implemented by all subclasses

Abstract Functions The member functions specified in an abstract class do not have to be implemented The implementation is left to the subclasses In C++, an abstract class is a class with at least one abstract member function

Pure Virtual Functions In C++, a member function of a class is declared to be an abstract function by making it virtual and replacing its body with = 0; class Animal{ public: virtual void id()=0; }; A virtual function with its body omitted and replaced with =0 is called a pure virtual function, or an abstract function See pr15-04.cpp

Abstract Classes An abstract class can not be instantiated An abstract class can only be inherited from; that is, you can derive classes from it Classes derived from abstract classes must override all pure virtual functions with concrete member functions before they can be instantiated.