These two functions define increment. As you know, it is possible to do a pre-increment, cout << ++i, which increments i before sending it to the output stream. It is also possible to do a post-increment, cout << i++, which increments i after sending it to the output stream. We need to have a way of distinguishing these two functions when implementing them. The way this is done in C++ is to indicate the post-increment operator by placing an int in the parameter list. In reality, an int is not passed to the function, it is just used to distinguish the two functions. The same is true for the decrement operators which follow.

The read function is not really necessary as the niceRead function does everything the read function does and more.

Originally, line 83 was:

However, we replaced the vector data member because it was a waste of space to include a copy of numDays in every Date object. In its place you make use of a static array. The static keyword indicates that only one instance of this array will be created even if more than one Date object is created. (This is the way static data members work.) Please note the code at the beginning of the date.cpp file initializes the array with the appropriate values. I chose to use an array instead of a vector because it made the initialization somewhat easier.

The monthNames array (line 83) holds a character array that specifies the name of each month. This array is used by the niceRead and niceDisplay functions and is a little cleaner than the obvious alternative of a switch statement or series of if statements. Similarly, an array of character arrays was chosen here to simplify initialization (see the beginning of date.cpp).

Some books/professors will make the extraction and insertion operators friends of the Date class. Doing this will allow them to access the private data members of the Date class. In that case, there is no need to create the display and read member functions. We could declare the insertion operator as a friend function by adding the following line anywhere in the class definition.

I would encourage you to avoid this practice. Allowing functions outside of the class to modify private data members opens the opportunity for the data members to be given (perhaps accidentally) invalid values. Even if you are able to make sure that the friend functions are only written/modified by the same person who wrote the class, it is still safer to create member functions that do the work and call them with the auxillary functions (the functions that are not members of the class). The main reason for this is that the auxillary functions cannot be made const functions whereas the member functions can.

Here we set the values of the data members in an initializer list. The initializer list allows us to assign values to the data members as they are instantiated (when memory is allocated for them). This is slightly more efficient than instantiating the objects before the constructor is called and then assigning values in the constructor.

Another way of dealing with the error checking would have just been to use the assert function. We could replace the entire function with the following line:

The assert function (it is really a macro, but we don't need to get into that here) is used when compiling in Debug mode. When the argument passed to assert is true, nothing happens. If the argument is false, an error message is display, and the program crashes. This can be handy when developing a program. We will make use of it periodically because it is an easy way to do some error checking. It is definitely not the best way to do error checking though. A more robust approach is to make use of exceptions to handle errors. We will discuss exceptions towards the end of the quarter. Perhaps we will come back to this example and deal with the errors "correctly" at that time.

I have included the preferred default constructor implementation above. If we did not have the static array for the number of days in each month, I would need to do something like this:

The 13 in the initializer list calls the vector class' one integer argument constructor. The constructor creates a vector with thirteen elements. Within the body of the function we must set the correct values for the vector.

Another, even less desirable version of the constructor is given below.

Suppose today is a Date object containing March 29, 2001. If I were to execute the following line of code:

I would expect that March 30, 2001 would be sent to the console output stream and that today would now contain March 30, 2001. In order for March 30, 2001 to be sent to the console output stream, ++today must evaluate to (i.e., return) a Date object with the value of March 30, 2001. Basically, we want to return the new value of today. We do this by making use of the this pointer.

The this pointer is a pointer that points to the object that called the member function that we are in (in this case, operator++()). We want to return the object (not a pointer to the object) that called operator++(), so we need to dereference the pointer. Hence, we return *this.

Suppose today is a Date object containing March 29, 2001. If I were to execute the following line of code:

I would expect that March 29, 2001 would be sent to the console output stream and that today would now contain March 30, 2001. In order for March 29, 2001 to be sent to the console output stream, ++today must evaluate to (i.e., return) a Date object with the value of March 29, 2001. We do this by making a copy of the original value of today (we call it temp in the above function). We then call the pre-increment operator to make today now contain March 30, 2001. Finally, we return the temp object which contains the original Date value.

The decrement operators are similar.

By making use of the monthNames array, this function is much less complicated than it would be if we had to write a switch statement with a case for each month. An alternative version of this function might look something like:

Notice how we made use of the monthNames array here. This function would be significantly more complicated if we didn't have the array. The alternative would be that we would have to have twelve if statements that would check to see if they matched strmn. Note: we could not use a switch statement here because the switch will not work on strings or character arrays. In place of the for loop (line 221) we would need to do something like this:

A year is a leap year if the year is either divisible by 400 (e.g., 2000) or not divisible by 100 but is divisible by 4 (e.g., 2004).