step is to see how C++ implements type polymorphism, and this Exploration starts you on that journey.

Transcription

1 EXPLORATION 36 Virtual Functions Deriving classes is fun, but there s not a lot you can do with them at least, not yet. The next step is to see how C++ implements type polymorphism, and this Exploration starts you on that journey. Type Polymorphism Recall from Exploration 34 that type polymorphism is the ability for a variable of type B to take the form of any class derived from B. The obvious question is: How? The key in C++ is to declare a function in a base class with a magic keyword, and also implement the function in a derived class. The magic keyword tells the compiler that you want to invoke type polymorphism. The compiler implements the polymorphism magic. Simply initialize a variable of type reference-to-base class with an object of derived-class type. When you call the polymorphic function for the object, the compiled code checks the object s true type, and calls the derived-class implementation of the function. The magic word to turn a function into a polymorphic function is. For example, suppose you want to be able to print any kind of work in the library (see Listing 35-1) using standard (more or less) bibliographical format. For books, I use the format: author, title, year. For periodicals, I use: title, volume(number), date. Add a member function to each class to print this information. Because this function has different behavior in each derived class, the function is polymorphic, so use the keyword before each declaration of, as shown in Listing Listing Adding a Polymorphic Function to Every Class Derived from 275

2 EXPLORATION 36 VIRTUAL FUNCTIONS 276

3 EXPLORATION 36 VIRTUAL FUNCTIONS 277 A program that has a reference to a can call the member function to print that work, and because is polymorphic, or virtual, the C++ environment performs its magic to ensure that the correct is called, depending on whether the object is actually a or a. To see this demonstrated, read the program in Listing Listing Calling the Function What output do you expect? Try it. What output do you actually get?

4 278 EXPLORATION 36 VIRTUAL FUNCTIONS The function does not need to know about the or classes. As far as it is concerned, is a reference to a object. The only member functions you can call are those declared in the class. Nonetheless, when calls, it will invoke s or s if the object s true type is or. Write an output operator () that prints a object by calling its member function. Compare your solution with my solution, as shown in Listing Listing Output Operator for Class Writing the output operator is perfectly normal. Just be certain you declare as a reference. Polymorphic magic does not occur with ordinary objects, only references. With this operator, you can write any k-derived object to an output stream, and it will print using its function. Virtual Functions A polymorphic function is called a virtual function in C++ due to the keyword. Once a function is defined as virtual, it remains so in every derived class. You don t need the keyword in the derived classes, but I like to include it as an aid and reminder to the human reader trying to distinguish virtual functions. In every derived class, the virtual function must have the same name, the same return type, and the same number and type of parameters (but the parameters can have different names). A derived class is not required to implement a virtual function. If it doesn t, it inherits the base class function the same way it does for a non-virtual function. When a derived class implements a virtual function, it is said to override the function because the derived class s behavior overrides the behavior that would have been inherited from the base class. Add a class,, to the library classes. The class represents a movie or film recording on tape or disc. Like and, the class derives from. For the sake of simplicity, define a as having an integer running time (in minutes) in addition to the members it inherits from. Do not override yet. Compare your class to Listing Listing Adding a Class

5 EXPLORATION 36 VIRTUAL FUNCTIONS 279 Now modify the test program from Listing 36-2 to create and print a object. If you want, you can take advantage of the new output operator instead of calling. Compare your program with Listing Listing Using the New Class What do you expect as the last line of output? Try it. What do you get? Because does not override, it inherits the implementation from the base class,. The definition of in the class does nothing, so printing the object prints nothing. Fix the problem by adding to the class. Now your movie class should look something like Listing 36-6.

6 280 EXPLORATION 36 VIRTUAL FUNCTIONS Listing Adding a Member Function to the Class Convince yourself that the keyword is optional in the derived class. Modify the class to remove the keyword from the print function. Does the program still work the way you expect it to? The key is that the base class must declare the function and must use the keyword. The compiler ensures that all calls to a virtual function via a reference are polymorphic calls. However, if you call the function from an ordinary object, not from a reference, the call is not polymorphic, and the compiler ignores the keyword, as you will see in the next section. References and Slices The function in Listing 36-2 and the output operator in Listing 36-3 declare their parameter as a reference to. What do you expect to happen if you were to change them to pass-by-value? Try it. Delete the ampersand in the declaration of the output operator, as shown in the following:

7 EXPLORATION 36 VIRTUAL FUNCTIONS 281 Run the test program from Listing What is the actual output? Explain what happened. When you pass an argument by value, or assign a derived-class object to a base-class variable, you lose polymorphism. For instance, instead of a, the result is an honest-togoodness, genuine, no-artificial-ingredients, with no memory of e-ness whatsoever. Thus, the output operator ends up calling s version of every time the output operator calls it. That s why the program s output is a bunch of empty lines. When you pass a object to the output operator, not only do you lose polymorphism, but you also lose all sense of k-ness. In particular, you lose the and data members. The data members that a derived class adds are sliced away when the object is copied to a base class variable. Another way to look at it is this: because the derived-class members are sliced away, what is left is only a object, so you cannot have polymorphism. The same thing happens with assignment. Slicing is easy to avoid when writing functions (pass all arguments by reference), but harder to cope with for assignment. The techniques you need to manage assignment come much later in this book; for now, I will focus on writing polymorphic functions. Pure Virtual Functions The class defines the function, but the function doesn t do anything useful. In order to be useful, every derived class must override. The author of a base class, such as, can ensure that every derived class properly overrides a virtual function by omitting the body of the function and substituting the tokens,, instead. These tokens mark the function as a pure virtual function, which means the function has no implementation to inherit, and derived classes must override the function.

8 282 EXPLORATION 36 VIRTUAL FUNCTIONS Modify the class to make a pure virtual function. Then delete the class s function, just to see what happens. What does happen? The compiler enforces the rules for pure virtual functions. A class that has at least one pure virtual function is said to be abstract. You cannot define an object of abstract type. Fix the program. The new class should look something like Listing Listing Defining As an Abstract Class Virtual Destructors Although most classes you are writing at this time do not need destructors, I want to mention an important implementation rule. Any class that has virtual functions must declare its destructor to be virtual, too. This rule is a programming guideline, not a semantic requirement, so the compiler will not help you by issuing a message when you break it (although some compilers may issue a warning). Instead, you need to enforce this rule yourself through discipline. I will repeat the rule when you begin to write classes that require destructors. If you try any experiments on your own, please be mindful of this rule, or else your programs could be subject to subtle problems or not-so-subtle crashes. The next Exploration continues the discussion of classes and their relationship in the C++ type system.