MSCU Library changes
Due to some of the difficulties in developing our classes, I have decided
to release my solution for the first 2 homework assignments involved in
developing this class. It wasn't really my intent, and I would like to stick
with the idea that the rest of the library be developed by the students.
In releasing my version of the classes, I have decided to also standardize
on some basic organization of the classes, and class files.
This document will address the changes in organization, and attempt to explain
some of the reasons behind certain decisions. Review my version, and this
document. If you already have these classes, you might find some changes
you wish to make to your own classes. Please do so with caution, and as
little as possible. In other words, do not throw away your code.
The version of the library this
document addresses defines the MSCUObject, MSCUDate, and MSCUSSN classes.
For organization purposes, things have broken down to the following files:
||Class definition of MSCUObject, and #include's
for other .h files|
||MSCUObject member functions|
||MSCUIDate class definition (included by mscui.h)|
||MSCUIDate member functions|
||MSCUSSN class definition (including all member
functions) (included by mscui.h)|
In the mscui.h file, you will find the #include statements needed
for other classes, such as MSCUIDate. Part of my goal here, is to make so
that you only have to include the mscui.h file to get full access
to all classes. While this is convenient to the programmer, it causes longer
compiler times, which I consider minimal, due to the size of our classes.
The Compare function
The Compare function defined
by MSCUObject is given an MSCUObject& as a parameter in the base class.
The comparison operators like operator== in the MSCUObject class
invoke this function with a MSCUObject&. In order to have the derived
class replace the MSCUIObject::Compare function, it must also take an MSCUIObject&.
In otherwords, if you wrote MSCUDate::Compre to take a MSCUDate& as
a parameter, and you were to give it an MSCUIObject& as a parameter
(such as is found in the test program), then the compiler would opt to use
the MSCUIObject::Compare function and not MSCUIDate::Compare.
This is because the type being passed by the MSCUIObject::operator== function
is an MSCUIObject&, not MSCUIDate, and the compiler finds the nearest
match in this case, the virtual function approach may not work as you would
In order to word around this, the Compare function for the date (and any
other MSCUIObject-derived class) is written so that it first makes sure
that the data type it receives is an MSCUIObject&. Then, the parameter's
type is checked against it's own datatype, using GetType. If the data types
are different, an exception is thrown. If they are the same, the address
of the MSCUIObject received by compare is type-case to a pointer to the
correct type (MSCUIDate in the example below), and then the comparison is
performed against that pointer. For example:
int MSCUDate::Compare( const MSCUObject&
if( GetType()!=Src.GetType() )
throw "Invalid type conversion";
const MSCUDate* pDate = (MSCUDate*)&Src;
if( Y!=pDate->Y )
return( Y - pDate->Y );
if( M != pDate->M )
return( M - pDate->M );
return( D - pDate->D );