Case Study: A Date Class
Case Study A Date Class
The program of Figs. 11.1211.14 demonstrates a Date class. The class uses overloaded prefix and postfix increment operators to add 1 to the day in a Date object, while causing appropriate increments to the month and year if necessary. The Date header file (Fig. 11.12) specifies that Date's public interface includes an overloaded stream insertion operator (line 11), a default constructor (line 13), a setDate function (line 14), an overloaded prefix increment operator (line 15), an overloaded postfix increment operator (line 16), an overloaded += addition assignment operator (line 17), a function to test for leap years (line 18) and a function to determine whether a day is the last day of the month (line 19).
Figure 11.12. Date class definition with overloaded increment operators.
|
1 // Fig. 11.12: Date.h 2 // Date class definition. 3 #ifndef DATE_H 4 #define DATE_H 5 6 #include 7 using std::ostream; 8 9 class Date 10 { 11 friend ostream &operator<<( ostream &, const Date & ); 12 public: 13 Date( int m = 1, int d = 1, int y = 1900 ); // default constructor 14 void setDate( int, int, int ); // set month, day, year 15 Date &operator++(); // prefix increment operator 16 Date operator++( int ); // postfix increment operator 17 const Date &operator+=( int ); // add days, modify object 18 bool leapYear( int ) const; // is date in a leap year? 19 bool endOfMonth( int ) const; // is date at the end of month? 20 private: 21 int month; 22 int day; 23 int year; 24 25 static const int days[]; // array of days per month 26 void helpIncrement(); // utility function for incrementing date 27 }; // end class Date 28 29 #endif |
Function main (Fig. 11.14) creates three Date objects (lines 1113)d1 is initialized by default to January 1, 1900; d2 is initialized to December 27, 1992; and d3 is initialized to an invalid date. The Date constructor (defined in Fig. 11.13, lines 1114) calls setDate to validate the month, day and year specified. An invalid month is set to 1, an invalid year is set to 1900 and an invalid day is set to 1.
Figure 11.13. Date class member- and friend-function definitions.
(This item is displayed on pages 610 - 611 in the print version)
|
1 // Fig. 11.13: Date.cpp 2 // Date class member-function definitions. 3 #include 4 #include "Date.h" 5 6 // initialize static member at file scope; one classwide copy 7 const int Date::days[] = 8 { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 9 10 // Date constructor 11 Date::Date( int m, int d, int y ) 12 { 13 setDate( m, d, y ); 14 } // end Date constructor 15 16 // set month, day and year 17 void Date::setDate( int mm, int dd, int yy ) 18 { 19 month = ( mm >= 1 && mm <= 12 ) ? mm : 1; 20 year = ( yy >= 1900 && yy <= 2100 ) ? yy : 1900; 21 22 // test for a leap year 23 if ( month == 2 && leapYear( year ) ) 24 day = ( dd >= 1 && dd <= 29 ) ? dd : 1; 25 else 26 day = ( dd >= 1 && dd <= days[ month ] ) ? dd : 1; 27 } // end function setDate 28 29 // overloaded prefix increment operator 30 Date &Date::operator++() 31 { 32 helpIncrement(); // increment date 33 return *this; // reference return to create an lvalue 34 } // end function operator++ 35 36 // overloaded postfix increment operator; note that the 37 // dummy integer parameter does not have a parameter name 38 Date Date::operator++( int ) 39 { 40 Date temp = *this; // hold current state of object 41 helpIncrement(); 42 43 // return unincremented, saved, temporary object 44 return temp; // value return; not a reference return 45 } // end function operator++ 46 47 // add specified number of days to date 48 const Date &Date::operator+=( int additionalDays ) 49 { 50 for ( int i = 0; i < additionalDays; i++ ) 51 helpIncrement(); 52 53 return *this; // enables cascading 54 } // end function operator+= 55 56 // if the year is a leap year, return true; otherwise, return false 57 bool Date::leapYear( int testYear ) const 58 { 59 if ( testYear % 400 == 0 || 60 ( testYear % 100 != 0 && testYear % 4 == 0 ) ) 61 return true; // a leap year 62 else 63 return false; // not a leap year 64 } // end function leapYear 65 66 // determine whether the day is the last day of the month 67 bool Date::endOfMonth( int testDay ) const 68 { 69 if ( month == 2 && leapYear( year ) ) 70 return testDay == 29; // last day of Feb. in leap year 71 else 72 return testDay == days[ month ]; 73 } // end function endOfMonth 74 75 // function to help increment the date 76 void Date::helpIncrement() 77 { 78 // day is not end of month 79 if ( !endOfMonth( day ) ) 80 day++; // increment day 81 else 82 if ( month < 12 ) // day is end of month and month < 12 83 { 84 month++; // increment month 85 day = 1; // first day of new month 86 } // end if 87 else // last day of year 88 { 89 year++; // increment year 90 month = 1; // first month of new year 91 day = 1; // first day of new month 92 } // end else 93 } // end function helpIncrement 94 95 // overloaded output operator 96 ostream &operator<<( ostream &output, const Date &d ) 97 { 98 static char *monthName[ 13 ] = { "", "January", "February", 99 "March", "April", "May", "June", "July", "August", 100 "September", "October", "November", "December" }; 101 output << monthName[ d.month ] << ' ' << d.day << ", " << d.year; 102 return output; // enables cascading 103 } // end function operator<< |
Figure 11.14. Date class test program.
(This item is displayed on page 612 in the print version)
|
1 // Fig. 11.14: fig11_14.cpp 2 // Date class test program. 3 #include 4 using std::cout; 5 using std::endl; 6 7 #include "Date.h" // Date class definition 8 9 int main() 10 { 11 Date d1; // defaults to January 1, 1900 12 Date d2( 12, 27, 1992 ); // December 27, 1992 13 Date d3( 0, 99, 8045 ); // invalid date 14 15 cout << "d1 is " << d1 << " d2 is " << d2 << " d3 is " << d3; 16 cout << " d2 += 7 is " << ( d2 += 7 ); 17 18 d3.setDate( 2, 28, 1992 ); 19 cout << " d3 is " << d3; 20 cout << " ++d3 is " << ++d3 << " (leap year allows 29th)"; 21 22 Date d4( 7, 13, 2002 ); 23 24 cout << " Testing the prefix increment operator: " 25 << " d4 is " << d4 << endl; 26 cout << "++d4 is " << ++d4 << endl; 27 cout << " d4 is " << d4; 28 29 cout << " Testing the postfix increment operator: " 30 << " d4 is " << d4 << endl; 31 cout << "d4++ is " << d4++ << endl; 32 cout << " d4 is " << d4 << endl; 33 return 0; 34 } // end main
|
Lines 1516 of main output each of the constructed Date objects, using the overloaded stream insertion operator (defined in Fig. 11.13, lines 96103). Line 16 of main uses the overloaded operator += to add seven days to d2. Line 18 uses function setDate to set d3 to February 28, 1992, which is a leap year. Then, line 20 preincrements d3 to show that the date increments properly to February 29. Next, line 22 creates a Date object, d4, which is initialized with the date July 13, 2002. Then line 26 increments d4 by 1 with the overloaded prefix increment operator. Lines 2427 output d4 before and after the preincrement operation to confirm that it worked correctly. Finally, line 31 increments d4 with the overloaded postfix increment operator. Lines 2932 output d4 before and after the postincrement operation to confirm that it worked correctly.
Overloading the prefix increment operator is straightforward. The prefix increment operator (defined in Fig. 11.13, lines 3034) calls utility function helpIncrement (defined in Fig. 11.13, lines 7693) to increment the date. This function deals with "wraparounds" or "carries" that occur when we increment the last day of the month. These carries require incrementing the month. If the month is already 12, then the year must also be incremented and the month must be set to 1. Function helpIncrement uses function endOfMonth to increment the day correctly.
The overloaded prefix increment operator returns a reference to the current Date object (i.e., the one that was just incremented). This occurs because the current object, *this, is returned as a Date &. This enables a preincremented Date object to be used as an lvalue, which is how the built-in prefix increment operator works for fundamental types.
Overloading the postfix increment operator (defined in Fig. 11.13, lines 3845) is trickier. To emulate the effect of the postincrement, we must return an unincremented copy of the Date object. For example, that int variable x has the value 7, the statement
cout << x++ << endl;
outputs the original value of variable x. So we'd like our postfix increment operator to operate the same way on a Date object. On entry to operator++, we save the current object (*this) in temp (line 40). Next, we call helpIncrement to increment the current Date object. Then, line 44 returns the unincremented copy of the object previously stored in temp. Note that this function cannot return a reference to the local Date object temp, because a local variable is destroyed when the function in which it is declared exits. Thus, declaring the return type to this function as Date & would return a reference to an object that no longer exists. Returning a reference (or a pointer) to a local variable is a common error for which most compilers will issue a warning.