Time(int h, int m, int s) { hrs = h; mins = m; secs = s; } void set(int h, int m, int s) { hrs = h; mins = m; secs = s; }

Transcription

1 Inheritance The following class implements time in hh:mm::ss format: class { public: () { = 0; = 0; = 0; (int h, int m, int s) { = h; = m; = s; void set(int h, int m, int s) { = h; = m; = s; void tick() { if (++ > 59) { = 0; if (++ > 59) { = 0; if (++ > 23) = 0; string get() const { ostringstream s; s.fill('0'); s << setw(2) << << ':'; s << setw(2) << << ':'; s << setw(2) << ; return s.str(); private: int ; int ; int ; ; Code that utilizes the class follows: void print( t) { cout << t.get() << endl; int main() { t; print(t); // 00:00:00 t.tick(); print(t); // 00:00:01 return 0; You may not be familiar with the ostringstream class. It's similar to the string class in that it contains a string, but you treat it like an output stream (ostream). If you wish to access the string stored in the ostringstream class, call the str member function. The C language has a similar feature. In C you can call printf to do formatted output to the console, or sprintf to do formatted output to a string.

2 Modifications The majority of software maintenance does not involve bug fixes. After software is released users often give valuable feedback and suggest changes or new features. Thus, the majority of software maintenance involves modifications to improve the product. Let's assume that users of this class like the current functionality, but also desire another format that incorporates a time zone. For example they wish to represent time in two different formats: 05:22:12 // current format 05:22:12 PST // incorporates time zone One solution is to write an class that represents extended time and includes the time zone. We note that must also set and increment time in the same manner as the existing class. Rather than repeating this logic in, let's reuse the code. The class will inherit the functionality of the existing class and extend the functionality of the class. class : public { public: enum ZoneEnum {EST, CST, MST, PST, EDT, CDT, MDT, PDT; () { zone = EST; (int h, int m, int s, ZoneEnum z): (h, m, s) { zone = z; void set(int h, int m, int s, ZoneEnum z) { ::set(h, m, s); zone = z; string get() const { static string zonestring[] = { "EST", "CST", "MST", "PST", "EDT", "CDT", "MDT", "PDT" ; return ::get() + " " + zonestring[zone]; private: ZoneEnum zone; ;

3 We indicate inheritance in the class declaration: class : public { This means that we are extending the class with new information. Here is the data represented by the and classes: zone The following program utilizes both and classes: void print(int n, t) { cout << n << ": " << t.get() << endl; void print(int n, t) { cout << n << ": " << t.get() << endl; int main() { t; print(1, t); // 1: t.tick(); print(2, t); // 2: et(3,4,5,::pst); print(3, et); // 3: t = et; print(4, t); // 4: print(5, et); // 5: et = t; print(6, t); // 6: *pt = &et; print(7, *pt); // 7: *pet = static_cast< *>(pt); print(8, *pet); // 8: print(9, *pet); // 9: return 0; What is the output of this program?

4 Virtual Inheritance It would be nice if we could write one print function that would print the time for both the class and the class. That is, the following function would work for both and classes: void print( t) { cout << t.get() << endl;... t; print(t); et; print(et); We need to make two modifications. First, to avoid slicing, we must pass the classes by reference. In this case we'll use const reference, since print will not be modifying the class. void print(const & t) { cout << t.get() << endl; et; print(et); Now we have an opportunity to display the zone in, since this information is not sliced as part of the call. A pointer to is passed to print, and this pointer actually points to an class that contains hours, minutes, seconds, and zone. However, this does not change the behavior of print. We still call 's get member function. Recall the layout for and : zone Function print believes it is viewing a class, even though it is pointing to an class. pointer to zone It never sees the data. To remedy this situation, we'll declare 's get member function virtual: virtual string get() const...

5 This causes the class, and all derived classes, to include a pointer to the appropriate get member function. For example, when we allocate an instance of the class, a pointer is included to 's get member function. t; *pt = &t; t pt get() ::get() In a similar manner, when we allocate an instance of the class, a pointer to 's get member function is included. et; *pet = &et; et get() ::get() pet zone When you call the get member function the pointer to the get function is dereferenced and the appropriate version of get is called. If there are several virtual functions, the pointers to the functions are placed in a table known as a vtable (vector table) of pointers. The compiler determines, when the class is allocated or instantiated, the contents of the vtable. Just as local variables override global variables, functions in derived classes override functions in base classes. Normal non-virtual inheritance is known as static or early binding. The compiler can figure out, at compile time, what function to call and generate code accordingly. Virtual inheritance is known as dynamic or late binding. In this case the program must determine which function to call at run time. How much overhead is associated with late binding in C++? Finally, let's review the changes we made to the class. The original class was widely used in existing code but lacked the ability to store a time zone. To add the zone we could have coded a separate class and a new print function that accepted an as a parameter. However, this meant re-coding the functionality in the existing class. Instead we opted to treat the existing class as a base class, and derive the class from the class. This means that the class inherits all the functionality of the class and this logic can be reused.

6 This functioned as desired, but left us with two separate print functions. Specifying the get member function virtual, and passing the class as a reference, we were able to code a single print function that works for both the and classes. Existing code that called print will work the same as before, and the zone will be incorporated when print is called with an class. Using inheritance we have extended the functionality of the class with minimal impact on existing code. Final Version #include <iostream> #include <sstream> #include <string> #include <iomanip> using namespace std; class { public: () { = 0; = 0; = 0; (int h, int m, int s) { = h; = m; = s; void set(int h, int m, int s) { = h; = m; = s; void tick() { if (++ > 59) { = 0; if (++ > 59) { = 0; if (++ > 23) = 0; virtual string get() const { ostringstream s; s.fill('0'); s << setw(2) << << ':'; s << setw(2) << << ':'; s << setw(2) << ; return s.str(); private: int ; int ; int ; ;

7 class : public { public: enum ZoneEnum {EST, CST, MST, PST, EDT, CDT, MDT, PDT; () { zone = EST; (int h, int m, int s, ZoneEnum z): (h, m, s) { zone = z; void set(int h, int m, int s, ZoneEnum z) { ::set(h, m, s); zone = z; virtual string get() const { static string zonestring[] = { "EST", "CST", "MST", "PST", "EDT", "CDT", "MDT", "PDT" ; return ::get() + " " + zonestring[zone]; private: ZoneEnum zone; ; void print(int n, const & t) { cout << n << ": " << t.get() << endl; int main() { t; print(1, t); // 1: t.tick(); print(2, t); // 2: et(3,4,5,::pst); print(3, et); // 3: t = et; print(4, t); // 4: print(5, et); // 5: et = t; print(6, t); // 6: *pt = &et; print(7, *pt); // 7: *pet = static_cast< *>(pt); print(8, *pet); // 8: print(9, *pet); // 9: return 0; What is the output of this program?

8 Protection Three levels of protection may be specified for class member functions and data: public. Anyone can access this item. private. Only member functions and friends can access this item. protected. Only member functions, friends, and derived classes can access this item. In our example,,, were private members of the class, while functions get and set were public members. In addition you may specify public, private, or protected when inheriting a base class. In our example we specified this in the declaration: class : public {... Public inheritance implies that users of can also access public members of. In addition, member functions of can also access protected members of. Private inheritance implies that public and protected members of are inherited as private. This bars users of, or any derived classes of, from access. Protected inheritance implies that public members of are inherited as protected. This bars users of from access, but derived classes of may still access these members. For example, we can change the protection in from private to protected and can access,, and directly. Typically protection is either public or private.