Object Oriented ProgrammingCOP3330 / CGS5409

Multiple Inheritance Template Classes and Functions

Inheritance is supported by most object oriented languages

C++ allows a special kind of inheritance known as multiple inheritance

This is NOT supported by all programming languages (ex: Java)

Multiple Inheritance simply means that a class can inherit properties from more than one base class

This means that a class can inherit from multiple parent classes

Former (older) implementation of the C++ stream libraries for file I/O (now replaced by template classes)

Recall the fstream library, and the classes: ◦ ifstream -- input file stream class◦ ofstream -- output file stream class

Recall the fstream library, and the classes: ◦ ifstream -- input file stream class◦ ofstream -- output file stream class

Former (older) implementation of the C++ stream libraries for file I/O (now replaced by template classes) used multiple inheritance

They shared a base class called fstreambase, which contained member functions relating to file-handling operations (ex: open() and close)

In the old implementation, the ifstream class inherited both from istream (for input features) and from fstreambase (for file features).

class ifstream : public fstreambase, public istream

{ ..... };

Similarly, ofstream was inherited from ostream (output features) and fstreambase (file features)

class ofstream : public fstreambase, public ostream

{ ..... };

Multiple inheritance is not a necessary feature of object-oriented programming, in general

Supported by some, but not by all

C++ allows multiple inheritance, while Java, for example, only allows single inheritance

class Date class Time DateTime.h -- class DateTime, inherited

from both Date and Time DateTime.cpp -- class DateTime definitions Pr15-17.cpp -- program that uses class

DateTime

// Specification file for the Date class#ifndef DATE_H#define DATE_Hclass Date{protected: int day; int month; int year;public: // Constructors Date() { day = 1; month = 1; year = 1900; } Date(int d, int m, int y) { day = d; month = m; year = y; } // Accessors int getDay() const { return day; } int getMonth() const { return month; } int getYear() const { return year; }};#endif

// Specification file for the Time class#ifndef TIME_H#define TIME_Hclass Time{protected: int hour; int min; int sec;public: // Constructors Time() { hour = 0; min = 0; sec = 0; } Time(int h, int m, int s) { hour = h; min = m; sec = s; } // Accessor functions int getHour() const { return hour; } int getMin() const { return min; } int getSec() const { return sec; }};#endif

// Specification file for the DateTime class#ifndef DATETIME_H#define DATETIME_H#include "Date.h"#include "Time.h"

// Constant for string sizeconst int DT_SIZE = 20;

class DateTime : public Date, public Time{protected: char dateTimeString[DT_SIZE];public: // Constructors DateTime(); DateTime(int, int, int, int, int, int); // Accessor function const char *getDateTime() const { return dateTimeString; }};#endif

// Implementation file for the DateTime class#include <cstring> // For strcpy and strcat#include <cstdlib> // For itoa#include "DateTime.h"// Constant for temp array sizeconst int TEMP_SIZE = 10;DateTime::DateTime() : Date(), Time() {strcpy(dateTimeString, "1/1/1900 0:0:0"); } DateTime::DateTime(int dy, int mon, int yr, int hr, int mt, int sc) : Date(dy, mon, yr), Time(hr, mt, sc){ char temp[TEMP_SIZE]; // Temporary work area for itoa() // Store the date in dateTimeString, in the form MM/DD/YY strcpy(dateTimeString, itoa(getMonth(), temp, TEMP_SIZE)); strcat(dateTimeString, "/"); strcat(dateTimeString, itoa(getDay(), temp, TEMP_SIZE)); strcat(dateTimeString, "/"); strcat(dateTimeString, itoa(getYear(), temp, TEMP_SIZE)); strcat(dateTimeString, " "); // Store the time in dateTimeString, in the form HH:MM:SS strcat(dateTimeString, itoa(getHour(), temp, TEMP_SIZE)); strcat(dateTimeString, ":"); strcat(dateTimeString, itoa(getMin(), temp, TEMP_SIZE)); strcat(dateTimeString, ":"); strcat(dateTimeString, itoa(getSec(), temp, TEMP_SIZE));}

// This program demonstrates a class with multiple inheritance.#include <iostream>#include "DateTime.h"using namespace std;

int main(){ // Define a DateTime object and use the default constructor to initialize it. DateTime emptyDay;

// Display the object's date and time. cout << emptyDay.getDateTime() << endl; // Define DateTime object initialized to date 2/4/60 and time 5:32:27. DateTime pastDay(2, 4, 60, 5, 32, 27); // Display the object's date and time. cout << pastDay.getDateTime() << endl; return 0;}

Function Templates make functions more versatile

Instead of defining a function for a single data type, we make a generic definition that works for ALL types

The generic definition allows the function to fill in the exact type later

Example: We could define a function that computes the maximum of three different numbers like this.

int maximum(int a, int b, int c) { int max = a; if (b > max)max = b;

if (c > max)max = c;

return max; }

However, this only works for int variables (or types that can be automatically converted, like shorts)

A template function allows this problem to be solved easily, with only one function (that will fit any of the basic types -- whether char, short, int, double, etc).

// Definition of function template maximum.

template < class T > // or template< typename T >T maximum( T value1, T value2, T value3 ){ T maximumValue = value1; // assume value1 is maximum

// determine whether value2 is greater than maximumValue if ( value2 > maximumValue ) maximumValue = value2;

// determine whether value3 is greater than maximumValue if ( value3 > maximumValue ) maximumValue = value3;

return maximumValue;} // end function template maximum

This is a templated function that prints the contents of an array, the items separated by spaces.

template< class T > void printArray( const T *array, const int count ) { for ( int i = 0; i < count; i++ ) cout << array[ i ] << " ";

cout << endl; }