INHERITANCE PART 2. Constructors and Destructors under. Multiple Inheritance. Common Programming Errors. CSC 330 OO Software Design 1

Transcription

1 INHERITANCE PART 2 Constructors and Destructors under Inheritance Multiple Inheritance private and protected Inheritance Common Programming Errors CSC 330 OO Software Design 1

2 What cannot be inherited? it Number of member functions cannot be inherited: Constructors t Destructors Assignment operators Friend functions CSC 330 OO Software Design 2

3 Derived Class Constructors A base class constructor is not inherited in a derived class The base class constructor can be invoked by the constructor of the derived class The constructor of a derived class begins by invoking the constructor of the base class in the initialization section CSC 330 OO Software Design 3

4 Example class BC { // base class BC( ) { x = y = -1; } // base constructor protected: int get_( ) const { return x; } int get_y ( ) const { return y; } int x ; int y ; class DC : public BC { // derived class void write( ) const { cout << get_x( ) * get_y( ) << \n'; } int main ( ) { DC dl; // dl.bc invoked dl.write( ); // 1 written to standard output } CSC 330 OO Software Design 4

5 Parent Constructors and Destructors When an object of a derived class (a subclass) is declared, then the parent s default constructor is called before the required constructor of the derived class. If the parent has a parent then the grandparent s default is called followed by the parent s default followed by the derived class constructor. In effect, for an arbitrary number of parents, the parent default constructors are called in a topdown fashion. The same thing happens with the destructors except it is down bottom-up (with the derived child class calling its own destructor first). CSC 330 OO Software Design 5

6 Example class Person { Person ( ) { } Person (string& s) { name =s; } string name; }; class Employee: public Person { Employee ( ) : salary (0) { } Employee (string& s, double sal) : Person (s), salary (sal) { } double salary; } Employee constructor invokes the Person constructor by default (implicitly) here Employee() : Person() automatically generated. } Employee constructors explicitly invokes a constructor of the Person class Employee e; < what happens here? CSC 330 OO Software Design 6

7 Parameters? A derived class will always invoke the constructor of the base class, as well as its own constructors. The base class constructor is always called first, followed by the constructor of the derived class, and so on down the tree. If the base class has a default constructor t inheritance is implicit. If it is necessary to invoke the constructorinitializer, this must be stated explicitly in each derived class. CSC 330 OO Software Design 7

8 Passing Parameters to the Base Class Constructor CSC 330 OO Software Design 8

9 Example class Animal { Animal() { species = "Animal ; } Animal( const char* s ) { species =s; } string species; class Primate: public Animal { Primate ( ) : Animal( "Primate" ) { } Primate( int n ) : Animal( "Primate" ) { heart_cham = n; } int heart_cham; Animal slug; // Animal( ) Animal tweety( "canary" ) ; // Animal( const char* ) Primate godzilla ; // Primate( ) Primate human( 4 ); // Primate( int ) CSC 330 OO Software Design 9

10 Default Initialization ation If a derived d class constructor t does not invoke a base class constructor explicitly, the base class default constructor will be used. If class B is derived d from class A and class C is derived from class B When a object of class C is created The base class A's constructor is the first invoked Class B's constructor is invoked next C's constructor completes execution CSC 330 OO Software Design 10

11 Example class Animal { Animal( ) { species = Animal ; } Animal( const char* s ) { species = s; } string species; class Primate: public Animal { Primate( ) : Animal( "Primate" ) { } Primate( int n ) : Animal( "Primate" ) { heart_cham =n; } int heart_cham; class Human : public Primate { Human( ) : Primate( ) { } Human( int c ) : Primate( c ) { } Human jill; // Human( ) Human fred( 4 ) ; // Human( int) CSC 330 OO Software Design 11

12 Derived Class Constructor Rules Example If a base class has constructors but not default constructor, then a derived class constructor must explicitly invoke some basic class constructor. // BC has constructors but no // default constructor class BC { // base class BC( int a ) { x = a; y = 999; } BC( int al, int a2 ) { x = al; y = a2; } int x; int y; // DC has a constructor (any constructor // will do for the example) class DC : public BC derived class // *** ERROR: DC( int ) must explicitly // invoke a BC constructor t DC( int n ) { z = n; } int z; CSC 330 OO Software Design 12

13 Example class BC { // base class BC( ) { cout << "BC::BC( ) executes... \n"; } int x; class DC : public BC { // derived class DC( ) { cout << "DC::DC ( ) executes\n"; } int y; int main( ) { DC d; //... BC::BC( ) DC::DC( () executes. executes CSC 330 OO Software Design 13

14 Fig // approach 1: have DC's constructor explicitly i l // invoke one of BC s constructors // approach 2: give BC a default constructor class BC { // base class class BC { // base class BC( int a ) { x = a; y = 999; } BC( ) { x = 1; y = 2; } // default BC( int al, int a2 ) { x = al; y = BC( int a ) { x = a; y = a2; } 999; } BC( int al, int a2} { x = al; y = a2; int x; } int y; int x; // DC's constructor explicitly invokes a int y; // BC constructor in its initialization section // DC's constructor ctor need not invoke a class DC : public BC { // derived class BC // constructor because BC how has a // ok: DC( int ) explicitly invokes BC( // default constructor int, int ) class DC : public BC { // derived class DC( int n ) : BC( n, n + 1) { z = n; } // ok: BC has a default constructor DC( int n ) { z = n; } int z; int z; CSC 330 OO Software Design 14

15 Rules using DC as a class derived from BC If DC has constructors but BC has no constructors, then the appropriate DC constructor executes automatically whenever a DC object is created. If DC has no constructors but BC has constructors, then BC must have a default constructor so that BC s default constructor can execute automatically whenever a DC object is created. If DC has constructors and BC has a default constructor, then BC s default constructor executes automatically whenever a DC object is created unless the appropriate DC constructor explicitly invokes, in its initialization, some other BC constructor. If DC and BC have constructors but BC has no default constructor, then each DC constructor must explicitly i l invoke, in its initialization section, a BC constructor, which then executes when a DC object is created. CSC 330 OO Software Design 15

16 Example class Team { // base class Team( int len = 100 ) { names = new string[ maxno = len ] ; } protected: string* names; int maxno; // class BaseballTeam : public Team { // derived class BaseballTeam( const string s[ ], int si ) : Team( si ) { } // for ( int i = 0; i < si; i++ ) names[ i ] = s[ i ]; CSC 330 OO Software Design 16

17 Destructors in Derived Classes If the base class has a working destructor, t defining the destructor for the defined class is relatively easy. When the destructor t for a derived d class is called, the destructor for the base class is automatically called. The derived d class destructor t need only use delete on dynamic variables added in the derived class, and data they may point to. CSC 330 OO Software Design 17

18 Destructors Sequence ence If class B is derived d from class A and class C is derived from class B When the destructor of an object of class C goes out of scope The destructor of class C is called Then the destructor of class B Then the destructor of class A Notice that destructors are called in the reverse order of constructor calls CSC 330 OO Software Design 18

19 Destructors Under Inheritance - Example class BC BC( ) { cout << BC's constructor\n ; } ~BC( ) { cout << BC's destructor\n"; } class DC : public BC { DC( ) : BC( ) { cout << "DC's constructor\n"; } ~DC( ) { cout << DC's destructor\n"; } }; int main ( ) { DC d; return 0; } BC's constructor DC's constructor DC's destructor BC's destructor CSC 330 OO Software Design 19

20 Fig Destructors freeing storage allocated by constructors class BC { // base class BC( ) { sbc = new char[ 3 ]; cout << "BC allocates 3 bytes\n"; } ~BC( ) { delete[ ] sbc; cout << "BC frees 3 bytes\n"; } char* sbc; class DC : public BC { // derived class DC( ) : BC( ) { sdc = new char[ 5 ] ; cout << "DC allocates 5 bytes\n"; } ~DC( ) { delete[ ] sdc; cout << "DC frees 5 bytes\n"; } char* sdc; int main( ) { DC dl; return 0; } CSC 330 OO Software Design 20

21 Example }; }; class Rect { // simple rectangle Rect(); ~Rect(); // ignore rest of the focus so that we can focus on the // automatic chaining int left, top; //upper-left corner int width, height; //size class Color { Color(); ~Color(); //.. int data; //color is stored compactly in an integer CSC 330 OO Software Design 21

22 Example(cont) class Textbox : public Rect { // a text box is a rectangle TextBox(); ~TextBox(); //.. Color textcolor; //color to draw text in -composition int framethickness; char *text; // text to draw }; Rect::Rect() { left = top = width = height = 0; cout << "in default constructor for: Rect \n"; } Rect::~Rect(){ cout << "in destructor for: Rect \n"; } CSC 330 OO Software Design 22

23 Example(cont) The default constructor and destructor for Color is much the same. TextBox::TextBox() { } framethickness = 0; text t = 0; cout << "in default constructor for: TextBox\n"; // member functions for TextBox Textbox::~TextBox() { cout << "in destructor for: TextBox\n"; if (text!= 0) free(text); } CSC 330 OO Software Design 23

24 Example(cont) main() { } TextBox tbox; //instantiate TextBox cout << ">> main() complete <<\n"; we get the result: in default constructor for: Rect in default constructor for: Color in default constructor for: TextBox >> main complete << in destructor for: TextBox in destructor for: Color in destructor for: Rect CSC 330 OO Software Design 24