1 Chapter 14 Object-Oriented Software Development Dale/Weems/Headington

2 Chapter 14 Topics l Structured Programming vs. Object-Oriented Programming Using Inheritance to Create a New C++ class Type Using Composition (Containment) to Create a New C++ class Type l Static vs. Dynamic Binding of Operations to Objects l Virtual Member Functions

3 Two Programming Paradigms Structural (Procedural) Object-Oriented PROGRAM PROGRAM FUNCTION OBJECT Operations Data OBJECT Operations Data OBJECT Operations Data

4 Object-Oriented Programming Language Features 1. Data abstraction 2. Inheritance of properties 3. Dynamic binding of operations to objects

5 OOP Terms C++ Equivalents ObjectClass object or class instance Instance variablePrivate data member MethodPublic member function Message passingFunction call ( to a public member function )

6 What is an object? OBJECT Operations Data set of methods (public member functions) internal state (values of private data members)

7 Inheritance Hierarchy Among Vehicles vehicle wheeled vehicleboat bicyclecar four-door two-door Every car is a wheeled vehicle.

8 Inheritance l is a mechanism by which one class acquires (inherits) the properties (both data and operations) of another class l the class being inherited from is the Base Class (Superclass) l the class that inherits is the Derived Class (Subclass) l the derived class is then specialized by adding properties specific to it

9 class Time Specification // SPECIFICATION FILE( time.h ) class Time { public : void Set ( int hours, int minutes, int seconds ) ; void Increment ( ) ; void Write ( ) const ; Time ( int initHrs, int initMins, int initSecs ) ; // constructor Time ( ) ; // default constructor private : int hrs ; int mins ; int secs ; } ; 9

10 Class Interface Diagram Private data: hrs mins secs Set Increment Write Time Time class

11 Using Inheritance to Add Features // SPECIFICATION FILE ( exttime.h) #include “time.h” enum ZoneType {EST, CST, MST, PST, EDT, CDT, MDT, PDT } ; class ExtTime : public Time // Time is the base class { public : void Set ( int hours, int minutes, int seconds, ZoneType timeZone ) ; void Write ( ) const ; ExtTime ( int initHrs, int initMins, int initSecs, ZoneType initZone ) ; // constructor ExtTime ( ) ; // default constructor private : ZoneType zone ; // added data member } ; 11

12 class ExtTime: public Time l says class Time is a public base class of the derived class ExtTime l as a result, all public members of Time (except constructors) are also public members of ExtTime l in this example, new constructors are provided, new data member zone is added, and member functions Set and Write are overridden

13 Class Interface Diagram Private data: hrs mins secs ExtTime class Set Increment Write Time Set Increment Write ExtTime Private data: zone

14 Client Code Using ExtTime #include “exttime.h”. ExtTime thisTime ( 8, 35, 0, PST ) ; ExtTime thatTime ; // default constructor called thatTime.Write( ) ; // outputs 00:00:00 EST cout << endl ; thatTime.Set (16, 49, 23, CDT) ; thatTime.Write( ) ; // outputs 16:49:23 CDT cout << endl ; thisTime.Increment ( ) ; thisTime.Write ( ) ; // outputs 08:35:02 PST cout << endl ; 14

15 Constructor Rules for Derived Classes l at run time, the base class constructor is implicitly called first, before the body of the derived class’s constructor executes l if the base class constructor requires parameters, they must be passed by the derived class’s constructor

16 Implementation of ExtTime Default Constructor ExtTime :: ExtTime ( ) // Default Constructor // Postcondition: // hrs == 0 && mins == 0 && secs == 0 // (via an implicit call to base class default constructor ) // && zone == EST { zone = EST ; }

17 Implementation of Another ExtTime Class Constructor ExtTime :: ExtTime ( /* in */ int initHrs, /* in */ int initMins, /* in */ int initSecs, /* in */ ZoneType initZone ) : Time (initHrs, initMins, initSecs) // constructor initializer // Precondition: 0 <= initHrs <= 23 && 0 <= initMins <= 59 // 0 <= initSecs <= 59 && initZone is assigned // Postcondition: //zone == initZone && Time set by base class constructor { zone = initZone ; } 17

18 Implementation of ExtTime::Set function void ExtTime :: Set ( /* in */ int hours, /* in */ int minutes, /* in */ int seconds, /* in */ ZoneType time Zone ) // Precondition: 0 <= hours <= 23 && 0 <= minutes <= 59 // 0 <= seconds <= 59 && timeZone is assigned // Postcondition: //zone == timeZone && Time set by base class function { Time :: Set (hours, minutes, seconds); zone = timeZone ; } 18

19 Implementation of ExtTime::Write Function void ExtTime :: Write ( ) const // Postcondition: //Time has been output in form HH:MM:SS ZZZ // where ZZZ is the time zone abbreviation { static string zoneString[8] = { “EST”, CST”, MST”, “PST”, “EDT”, “CDT”, “MDT”, “PDT” } ; Time :: Write ( ) ; cout << ‘ ‘ << zoneString [zone] ; } 19

20 often several program files use the same header file containing typedef statements, constants, or class type declarations--but, it is a compile-time error to define the same identifier twice l this preprocessor directive syntax is used to avoid the compilation error that would otherwise occur from multiple uses of #include for the same header file #ifndef Preprocessor_Identifier #define Preprocessor_Identifier. #endif Avoiding Multiple Inclusion of Header Files

21 Composition (or Containment) l is a mechanism by which the internal data (the state) of one class includes an object of another class

22 A TimeCard object has a Time object #include “time.h” class TimeCard { public: void Punch ( /* in */ int hours, /* in */ int minutes, /* in */ int seconds ) ; void Print ( ) const ; TimeCard ( /* in */ long idNum, /* in */ int initHrs, /* in */ int initMins, /* in */ int initSecs ) ; TimeCard ( ) ; private: long id ; Time timeStamp ; } ;

23 TimeCard Class TimeCard has a Time object Private data: hrs mins secs Punch Private data: id timeStamp Increment Set Print. TimeCard Write.

24 Implementation of TimeCard Class Constructor TimeCard :: TimeCard ( /* in */ long idNum, /* in */ int initHrs, /* in */ int initMins, /* in */ int initSecs ) : timeStamp (initHrs, initMins, initSecs) // constructor initializer // Precondition: 0 <= initHrs <= 23 && 0 <= initMins <= 59 // 0 <= initSecs <= 59 && initNum is assigned // Postcondition: //id == idNum && timeStamp set by its constructor { id = idNum ; } 24

25 Order in Which Constructors are Executed Given a class X, l if X is a derived class its base class constructor is executed first l next, constructors for member objects (if any) are executed (using their own default constructors if none is specified) l finally, the body of X’s constructor is executed

26 In C++... When the type of a formal parameter is a parent class, the argument used can be: the same type as the formal parameter, or, any descendant class type.

27 Static Binding l is the compile-time determination of which function to call for a particular object based on the type of the formal parameter l when pass-by-value is used, static binding occurs

28 Static Binding Is Based on Formal Parameter Type void Print ( /* in */ Time someTime ) { cout << “Time is “ ; someTime.Write ( ) ; cout << endl ; } CLIENT CODE OUTPUT Time startTime ( 8, 30, 0 ) ;Time is 08:30:00 ExtTime endTime (10, 45, 0, CST) ;Time is 10:45:00 Print ( startTime ) ; Print ( endTime ) ;

29 Dynamic Binding l is the run-time determination of which function to call for a particular object of a descendant class based on the type of the argument l declaring a member function to be virtual instructs the compiler to generate code that guarantees dynamic binding

30 Virtual Member Function // SPECIFICATION FILE ( time.h ) class TimeType { public :... virtual void Write ( ) const ; // for dynamic binding... private : int hrs ; int mins ; int secs ; } ;

31 Dynamic binding requires pass-by-reference void Print ( /* in */ Time & someTime ) { cout << “Time is “ ; someTime.Write ( ) ; cout << endl ; } CLIENT CODE OUTPUT Time startTime ( 8, 30, 0 ) ; Time is 08:30:00 ExtTime endTime (10, 45, 0, CST) ; Time is 10:45:00 CST Print ( startTime ) ; Print ( endTime ) ;

32 Using virtual functions in C++ l dynamic binding requires pass-by-reference when passing a class object to a function l in the declaration for a virtual function, the word virtual appears only in the base class l if a base class declares a virtual function, it must implement that function, even if the body is empty l a derived class is not required to re-implement a virtual function. If it does not, the base class version is used