Extending Classes (contd.) (Chapter 15) Questions:

Transcription

1 Extending Classes (contd.) (Chapter 15) Questions: 1

2 Virtual Functions in C++ Employee /\ / \ ---- Manager 2

3 Case 1: class Employee { string firstname, lastname; //... Employee( string fnam, string lnam ) { firstname = fnam; lastname = lnam; } void print() const { cout << firstname << " " << lastname << endl; } class Manager : public Employee { short level; //.. Manager( string fnam, string lnam, short lvl ) : Employee( fnam, lnam ), level( lvl ) {} } void print() const { Employee::print(); cout << "level: " << level << endl; } 3

4 vector<employee*> emplist; Employee* e1 = new Employee( "john", "doe" ); Employee* e2 = new Employee( "jane", "doe" ); Manager* e3 = new Manager( "mister", "bigshot", 2); Manager* e4 = new Manager( "ms", "importante", 10); Note that for the last two employees, we could also have said Employee* e3 = new Manager( "mister", "bigshot", 2); Employee* e4 = new Manager( "ms", "importante", 3); 4

5 emplist.push_back( e1 ); emplist.push_back( e2 ); emplist.push_back( e3 ); emplist.push_back( e4 ); vector<employee*>::iterator p = emplist.begin(); while ( p < emplist.end() ) (*p++)->print(); john doe jane doe mister bigshot ms importante 5

6 If we want the system to automatically use Manager::print() for items of typemanager*, we have to declare the functionprint() as avirtual function in the base class. class Employee { string firstname, lastname; //... Employee( string fnam, string lnam ) { firstname = fnam; lastname = lnam; } virtual void print() const { cout << firstname << " " << lastname << endl; } john doe jane joe mister bigshot at level: 2 ms importante at level: 3 6

7 Restrictions on Virtual Function Declarations A requirement on a virtual function is that such a function must be defined for the class in which it is first declared, unless it is declared to be a pure virtual function. Additionally, although a virtual function will typically be in the protected or the public sections of a class, since only those members are visible in a derived class, it is legal and sometimes very useful to define a virtual function in the private section of a class. 7

8 Virtual Functions in Multi-level Hierarchies: Person /\ / \ ---- Employee /\ / \ ---- Manager 8

9 vector<employee*> emplist; Employee* e1 = new Employee( "mister", "bigshot", 2 ); Employee* e2 = new Employee( "ms", "importante", 3); Manager* m3 = new Manager( "mister", "biggun", 5, 2 ); Manager* m4 = new Manager( "ms", "shiningstar", 5, 2 ); emplist.push_back( e1 ); emplist.push_back( e2 ); emplist.push_back( m3 ); emplist.push_back( m4 ); 9

10 Will the print() function exhibit polymorphic behavior on this list of Employee objects even though the virtual declaration was made for the Person class? The answer is yes. Once a function is declared to be virtual at any depth in a hierarchy, it will exhibit polymorphic behavior with respect to all classes at and below that level in the hierarchy. 10

11 Can Operators be Made to Behave Polymorphically? Employee* e_ptr = new Manager( "ms", "importante", 3); cout << *e_ptr; Employee* e_ptr = new Manager( "ms", "importante", 3); Manager* m_ptr = static_cast<manager*>( e_ptr ); cout << *m_ptr; 11

12 Polymorphic Types: When a class has at least one virtual function, the class defines a polymorphic type. 12

13 Static versus Dynamic Binding for Functions in C++ When the exact function to be invoked can be determined at compile time, we refer to that as a static binding of the function to the function call. 13

14 class UserProfile { string name; int age; //... UserProfile( string str, int yy ) : name(str), age( yy ) {} //(A) UserProfile( string str ) : name( str ) { age = averageage(); } //(B) int averageage(){ return 48; } //... int main() { UserProfile user1( "Zaphod", 112 ); UserProfile user2( "Trillion" ); //... } //(C) //(D) 14

15 For a virtual function, the choice of which specific function to invoke can only be made at run time through what s known as dynamic binding. 15

16 What costs are associated with dynamic binding and how do these costs depend on the complexity of a class (in terms of, say, the number of virtual functions defined for a class, etc.)? For most programming, these costs are completely insignificant and can safely be ignored. 16

17 Each class that either has its own virtual functions or that inherits virtual functions from a superclass is provided with a virtual table, commonly referred to as vtbl, that contains pointers to the implementations of virtual functions for that class. class X { //... X(); virtual void f1(); virtual void f2(); void f3(); ~X(); class Y : public X { //... void f4(); virtual f5(); 17

18 vtbl for class X f1 pointer to the implementation code for f f2 pointer to the implementation code for f vtbl for class Y f1 pointer to the implementation code for f f2 pointer to the implementation code for f f5 pointer to the implementation code for f

19 The virtual table of a class is stored somewhere in the memory outside the class and the class is given a pointer to the table. This pointer is called a virtual table pointer, commonly referred to by the symbol vtpr. A vtpr pointer is a hidden data member in every class that has at least one virtual function defined directly in the class or inherited from a superclass. 19

20 class X { int n; X( int nn ) : n( nn ) {} virtual ~X(){} int main(){ cout << sizeof( X ) << endl; // 8 } 20

21 class X { //... virtual void foo(); class Y : public X { //... void foo(); int main() { X* p; //... // p could be made to point to either // an X object or a Y object //... p->foo(); } 21

22 Calls to virtual functions also extract another performance penalty: interference with compiler optimizations through function inlining. 22

23 Restrictions on Overriding Functions When a function is declared to be virtual in a base class, it can be overridden by its definition in a derived class. The overriding function definition in the derived class must not violate certain restrictions: 23

24 1. When the values returned are of primitive types, the return type of the overriding function in a derived class must be the same as the return type of the overridden function in the base class. class X { virtual float foo( double m ) { return m; } class Y : public X { double foo( double n ) { return n; } // Error 24

25 2. When the returned values are pointers or references to class types, the return type of an overriding function is allowed to be a subclass of the type returned by the base-class virtual function. 25

26 #include <iostream> using namespace std; class X { class Y : public X { // BASE // DERIVED class Base { virtual X* bar() { // BASE cout << "Base s bar invoked" << endl; return new X(); } virtual ~Base(){} //(A) class Derived : public Base { // DERIVED Y* bar() { //(B) cout << "Derived s bar invoked" << endl; return new Y(); } ~Derived(){} int main() { Base* b = new Derived(); b->bar(); // program s output: Derived s bar invoked delete b; return 0; } 26

27 3. The access restriction on the base class virtual function plays no role in the legality of an override definition in a derived class. Obviously, if the base-class virtual function is in the public section, the derived class s override definition can be in either the private, or the protected, or the public section. But the same is true if the base-class virtual function is either private or protected. 27

28 //PrivateVirtual.cc #include <iostream> using namespace std; class Base { // BASE int m; virtual void foo(){cout <<"Base s foo invoked"<< endl;} //(C) Base( int mm ) : m( mm ) {} void bar() { foo(); } //(D) virtual ~Base(){} //(E) class Derived : public Base { // DERIVED int n; void foo() { cout << "Derived s foo invoked" << endl; } //(F) Derived( int mm, int nn ) : Base( mm ), n( nn ) {} ~Derived(){} int main() { Base* p = new Derived( 10, 20 ); //(G) p->bar(); //output: Derived s foo invoked //(H) delete p; return 0; } 28

29 4. An overriding function in a derived class is not allowed to throw an exception that is excluded by the exception specification of the overridden function in the base class. 29

30 #include <iostream> using namespace std; class E1 { class E2 : public E1 { class E3 { // BASE exception type // DERIVED exception type class Base { // BASE int m; Base( int mm ) : m( mm ) {} virtual void foo() throw( E1 ) { cout << "Base s foo" << endl; throw E1(); } virtual ~Base() {} class Derived_1 : public Base { // DERIVED int n; Derived_1( int mm, int nn ) : Base( mm ), n( nn ) {} void foo() throw( E2 ) { cout << "Derived_1 s foo" << endl; throw E2(); } ~Derived_1() {} //(I) //(J) class Derived_2 : public Base { // DERIVED int p; Derived_2( int mm, int pp ) : Base( mm ), p( pp ) {} 30

31 // void foo() throw (E3) {} //ERROR //(K) ~Derived_2() {} int main() { Base* p = new Derived_1( 10, 20 ); try { p->foo(); } catch( E1 e ) { cout << "caught E1" << endl; } delete p; return 0; } //(L) 31

32 The output of the program is Derived_1 s foo caught E1 indicating that even though we invoked foo on a base-class pointer in line (L) of main, it was the Derived 1 s definition of foo that was used. 32

33 Virtual Destructors in C++ Even when a base class does not directly appropriate system resources, you may still need to declare its destructor virtual if you want polymorphic destruction of derived-class objects. 33

34 Consider the case of a vector of pointers to the base-class type, where some of the pointers are actually pointing to objects of a derived-class type. Let s say that you now set up a loop in which you invoke the delete operator on each of the pointers, with the hope that the destructor invoked for each object would be the one defined specifically for it. In other words, you d want the destructor invocation to behave polymorphically. This will only happen if you declare the destructor to be virtual in the base class. 34

35 #include <iostream> using namespace std; class X { virtual ~X(); // BASE //(A) X::~X(){ cout << "X s destructor" << endl; } //(B) class Y : public X { // DERIVED ~Y() { cout << "Y s destructor" << endl; } class Z : public Y { // DERIVED ~Z() { cout << "Z s destructor" << endl; } int main() { X* p = new Z(); //(C) delete p; //(D) return 0; } 35

36 Inmain of the above program, we construct an object of typezand assign it to a base-class pointer of type X* in line (C). When we invoke delete on this pointer in line (D), we get the following output from the program: Z s destructor Y s destructor X s destructor 36

37 What would be the output of the program for the following in main: Y* q = new Z(); delete q; What would be the output of the program if the keyword virtual was dropped in line (A) of the program? 37

38 Constructor Order Dependencies in C++ Order dependency in a derived-class constructor refers to the order in which the base-class sub-objects are constructed inside a derived-class object; the order in which the specified initializations carried for the data members of the derived class; etc. 38

39 class X { X() { cout << "X object under construction" << endl; } class Y { Y() { cout << "Y object under construction" << endl; } class Base { X xobj; // (A) Y yobj; // (B) Base() : xobj( X() ), yobj( Y() ) {} // (C) int main() { Base b; } 39

40 The official rules for the order in which the code for a derived-class constructor is executed are: 1. When a derived-class constructor is invoked, first the memory needed for constructing the derived-class object is appropriated. 2. Next, the constructor of the base-class is invoked to construct the baseclass slice of the derived-class object. (If the derived class has multiple bases, the base-class constructor for each base is invoked in the order in which the bases are declared in the header of the derived class, and regardless of the order used by the programmer in his/her coding of the derived-class constructor.) 3. If the derived-class constructor uses the member initialization syntax for the data member of the derived class, invoke the initializers in the order in which the data members are declared in the class definition, and regardless of the order they are shown in the member initialization syntax by the programmer. 4. Execute the code in the body of the derived-class constructor. 40

41 class X { virtual void foo(){ cout << "X s foo invoked" << endl; } X() { foo(); } class Y : public X { void foo(){ cout << "Y s foo invoked" << endl; } Y() {} int main() { Y yobj; } 41