CSC270 Tutorial: C++ Inheritance and Virtual Functions


One class can be built upon another. For example, in the current simulation assignment the Event class serves as a basis for the following classes: TrainDepartureEvent, TrainAdvanceEvent, TrainSwitchCheckingEvent, PassengerAppearanceEvent, and ReportEvent. class Event { friend class Scheduler; protected: float time; // time of event virtual void handleEvent() {} // function to handle the event }; An Event has a time and a function handleEvent(). The word "protected" means that the components of Event are visible to only those classes derived from Event. If it were "public", all class could see the components, while if it were "private", no classes (including derived classes) could see the components.

Virtual Functions

handleEvent() is a "virtual function", which means that its code can be redefined in classes that are derived from the Event class. The PassengerAppearanceEvent class is derived from the Event class. We say that PassengerAppearanceEvent "inherits" the components of the Event class. Event is the "base class" and PassengerAppearanceEvent is the "derived class". class PassengerAppearanceEvent : public Event { Passenger *passenger; Station *station; public: PassengerAppearanceEvent( float eventTime, Passenger *p, Station *s ) { time = eventTime; passenger = p; station = s; } void handleEvent(); }; The syntax used above indicates that PassengerAppearanceEvent is derived from Event. The "public" keyword before "Event" indicates that public components of Event are also public in PassengerAppearanceEvent. That is, they are visible from outside PassengerAppearanceEvent. However, protected components of Event are NOT public in PassengerAppearanceEvent. We could also use the "private" keyword, in which case public components of the base class would be private components of the derived class and would not be visible outside the derived class. If not keyword is present, "private" is assumed. The constructor above shows that, when created, a PassengerAppearanceEvent event stores the event time, the passenger who appears, and the station at which the passenger appears. The PassengerAppearanceEvent class has all the variables of its base class (i.e. time), in addition to its own variables (i.e. passenger and station).

Usefulness of virtual functions

The virtual function is very useful. We can maintain an array containing pointers to different types of events without knowing exactly what types they are: Event* events[100]; Since we know that all Events have a time and a handleEvent() function, we can find the event of minimum time and `handle' it, regardless of the actual type of the event. min = 0; for (i=1; i<100; i++) // find the event of minimum time if (events[i]->time < events[min]->time) min = i; events[min]->handleEvent(); // handle it Note that the handleEvent() function called above will be different for the different types of Event. That is, PassengerAppearanceEvent has one version of handleEvent(), TrainDepartureEvent (which is derived from Event) has another version, and ReportEvent (also derived from Event) has yet another version. C++ uses a technique called "dynamic binding" to determine, during execution, what version of the function to execute. This is all hidden from the programmer.