TOC PREV NEXT INDEX

C++: A Dialog

11.5. Hiding Unnecessary Information from the class User

That rule applies only to functions that are accessible to the user of the polymorphic object. The GetType function is intended for use only in the implementation of the polymorphic object, not by its users; therefore, it is not only possible but desirable to keep it "hidden" by declaring it inside one of the worker classes. Because the user never creates an object of any of the worker classes directly, declaring a function in one of those classes has much the same effect as making it a private member function. As we have already seen, hiding as many implementation details as possible helps to improve the robustness of our programs.
I should also mention the different data types for member variables in the HomeItem classes that have similar functions to those in the StockItem classes. In HomeItemBasic, we are using a long to hold a date, where we used a string in the DatedStockItem class. A sufficient reason for this change is that in the current class, we are getting the date from the user, so we don't have the problem of converting the system date to a storable value as we did with the implementation of the former class. As for the double we're using to store the price information, that's a more sensible data type than short for numbers that may have decimal parts. I avoided using it in the earlier example only to simplify the presentation, but at this point I don't think it should cause you any trouble.
Aside from these details, this polymorphic object's definition is very similar to the one for the StockItem polymorphic object. The similarity between the interfaces (and corresponding similarity of implementations) of polymorphic objects is good news because it makes generating a new polymorphic object interface and basic implementation quite easy. It took me only a couple of hours to write the initial version of the HomeItem classes using StockItem as a starting point. What is even more amazing is that the test program (Figure 11.3) worked correctly the very first time I ran it!1

The Initial HomeItem Test Program

FIGURE 11.3. The initial test program for the HomeItem classes (code\hmtst1.cpp)
// hmtst1.cc

#include <iostream>
#include <fstream>
#include <string>
#include "Vec.h"
#include "hmit1.h"
using namespace std;

int main()
{
HomeItem x;
HomeItem y;

ifstream HomeInfo("home1.in");

HomeInfo >> x;

HomeInfo >> y;

cout << "A basic HomeItem: " << endl;
cout << x;

cout << endl;

cout << "A music HomeItem: " << endl;
cout << y;

return 0;
}

I don't think that program needs much explanation. It is exactly the same as the corresponding StockItem test program in Figure 10.21 on page 696, with the obvious exception of the types of the objects and the name of the ifstream used to read the data. Figure 11.4 shows the result of running the above program.
FIGURE 11.4. Results of running the first HomeItem test program (code\hmit1.out)
A basic HomeItem:
Basic
Living room sofa
1600
19970105
Our living room sofa
Furniture

A music HomeItem:
Music
Relish
12.95
19950601
Our first album
CD
Joan Osborne
2
Right Hand Man
Ladder

Now that we've gone over the interfaces for the classes that cooperate to make a polymorphic HomeItem object, as well as the first test program and its output, we can see the initial implementation in Figure 11.5.
FIGURE 11.5. Initial implementation of HomeItem manager and worker classes (code\hmit1.cpp)
// hmit1.cpp

#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>

#include "Vec.h"

#include "hmit1.h"
#include "hmiti1.h"
using namespace std;


//friend functions of HomeItem

ostream& operator << (ostream& os, const HomeItem& Item)
{
Item.m_Worker->Write(os);
return os;
}

istream& operator >> (istream& is, HomeItem& Item)
{
string Type;
string Name;
double PurchasePrice;
long PurchaseDate;
string Description;
string Category;

while (Type == "")
{
getline(is,Type);
if (is.fail() != 0)
{
Item = HomeItem();
return is;
}
}

getline(is,Name);
is >> PurchasePrice;
is >> PurchaseDate;
is.ignore();
getline(is,Description);
getline(is,Category);

if (Type == "Basic")
{
Item = HomeItem(Name, PurchasePrice, PurchaseDate,
Description, Category);
}
else if (Type == "Music")
{
string Artist;
short TrackCount;
getline(is,Artist);
is >> TrackCount;
is.ignore();
Vec<string> Track(TrackCount);
for (short i = 0; i < TrackCount; i ++)
{
getline(is,Track[i]);
}
Item = HomeItem(Name, PurchasePrice, PurchaseDate,
Description, Category, Artist, Track);
}
else
{
cout << "Can't create object of type " << Type << endl;
exit(1);
}

return is;
}


// HomeItem member functions

HomeItem::HomeItem()
: m_Count(0), m_Worker(new HomeItemBasic)
{
m_Worker->m_Count = 1;
}

HomeItem::HomeItem(const HomeItem& Item)
: m_Count(0), m_Worker(Item.m_Worker)
{
m_Worker->m_Count ++;
}

HomeItem& HomeItem::operator = (const HomeItem& Item)
{
HomeItem* temp = m_Worker;

m_Worker = Item.m_Worker;
m_Worker->m_Count ++;

temp->m_Count --;
if (temp->m_Count <= 0)
delete temp;

return *this;
}

HomeItem::~HomeItem()
{
if (m_Worker == 0)
return;

m_Worker->m_Count --;
if (m_Worker->m_Count <= 0)
delete m_Worker;
}

HomeItem::HomeItem(string Name, double PurchasePrice,
long PurchaseDate, string Description,
string Category)
: m_Count(0),
m_Worker(new HomeItemBasic(Name, PurchasePrice,
PurchaseDate, Description, Category))
{
m_Worker->m_Count = 1;
}

HomeItem::HomeItem(int)
: m_Worker(0)
{
}

HomeItem::HomeItem(string Name, double PurchasePrice,
long PurchaseDate, string Description,
string Category, string Artist,
Vec<string> Track)
: m_Count(0),
m_Worker(new HomeItemMusic(Name, PurchasePrice,
PurchaseDate, Description, Category, Artist, Track))
{
m_Worker->m_Count = 1;
}


void HomeItem::Write(ostream& )
{
exit(1); // error
}

// HomeItemBasic member functions

HomeItemBasic::HomeItemBasic()
: HomeItem(1),
m_Name(),
m_PurchasePrice(0),
m_PurchaseDate(0),
m_Description(),
m_Category()
{
}

HomeItemBasic::HomeItemBasic(string Name,
double PurchasePrice, long PurchaseDate,
string Description, string Category)
: HomeItem(1),
m_Name(Name),
m_PurchasePrice(PurchasePrice),
m_PurchaseDate(PurchaseDate),
m_Description(Description),
m_Category(Category)
{
}

void HomeItemBasic::Write(ostream& os)
{
os << GetType() << endl;
os << m_Name << endl;
os << m_PurchasePrice << endl;
os << m_PurchaseDate << endl;
os << m_Description << endl;
os << m_Category << endl;
}

string HomeItemBasic::GetType()
{
return "Basic";
}


// HomeItemMusic member functions

HomeItemMusic::HomeItemMusic(string Name,
double PurchasePrice, long PurchaseDate,
string Description, string Category,
string Artist, Vec<string> Track)
: HomeItemBasic(Name,PurchasePrice,PurchaseDate,
Description, Category),
m_Artist(Artist),
m_Track(Track)
{
}

void HomeItemMusic::Write(ostream& os)
{
HomeItemBasic::Write(os);

os << m_Artist << endl;

int TrackCount = m_Track.size();
os << TrackCount << endl;
for (short i = 0; i < TrackCount; i ++)
os << m_Track[i] << endl;
}

string HomeItemMusic::GetType()
{
return "Music";
}

What does this first version of HomeItem do for us? Not too much; it merely allows us to read HomeItem objects from a file, display them, and write them out to a file. Although we've seen the implementation of similar functions in the StockItem class, it should still be worthwhile to discuss how these are similar to and different from the corresponding functions in the HomeItem classes. However, to avoid too much repetition we'll skip the functions that are essentially identical in these two cases, including the following functions for the base class, HomeItem:
1. operator <<;
2. the copy constructor;
3. the default constructor;
4. operator =;
5. the destructor;
6. the normal constructors that create worker objects with known initial data;
7. the "special" constructor that prevents an infinite regress when creating a worker object.
Here's a list of the functions we'll skip for the HomeItemBasic and HomeItemMusic classes:
1. the default constructor;
2. the copy constructor;
3. operator =;
4. the normal constructor;
5. the destructor.
The first HomeItem function we'll discuss is Write, shown in Figure 11.6.
FIGURE 11.6. HomeItem::Write (from code\hmit1.cpp)
void HomeItem::Write(ostream& )
{
exit(1); // error
}

Calling this function is an error and will cause the program to exit. In case you're wondering why this is an error, you may be happy to know that Susan had the same question.
Susan: Why is calling HomeItem::Write an error?
Steve: Because this function exists solely for use by operator << in writing out the data for a derived class object. Therefore, if it is ever called for a HomeItem base class object, we know that someone has used the function incorrectly, and we leave the program before any more incorrect processing can occur.
The next function we need to look at is operator >>, shown in Figure 11.7.
FIGURE 11.7. The HomeItem implementation of operator >> (from code\hmit1.cpp)
istream& operator >> (istream& is, HomeItem& Item)
{
string Type;
string Name;
double PurchasePrice;
long PurchaseDate;
string Description;
string Category;

while (Type == "")
{
getline(is,Type);
if (is.fail() != 0)
{
Item = HomeItem();
return is;
}
}

getline(is,Name);
is >> PurchasePrice;
is >> PurchaseDate;
is.ignore();
getline(is,Description);
getline(is,Category);

if (Type == "Basic")
{
Item = HomeItem(Name, PurchasePrice, PurchaseDate,
Description, Category);
}
else if (Type == "Music")
{
string Artist;
short TrackCount;
getline(is,Artist);
is >> TrackCount;
is.ignore();
Vec<string> Track(TrackCount);
for (short i = 0; i < TrackCount; i ++)
{
getline(is,Track[i]);
}
Item = HomeItem(Name, PurchasePrice, PurchaseDate,
Description, Category, Artist, Track);
}
else
{
cout << "Can't create object of type " << Type << endl;
exit(1);
}

return is;
}

This is quite similar in outline to the corresponding function in StockItem in that it reads data from an input source and creates a worker object of the correct type based on the value of one of the fields. However, this function does have a few noticeable differences from the StockItem version:
1. This function skips any empty lines that may be in the input file before reading the type of the object.
2. The type is specified explicitly as an extra field ("Basic" or "Music" in the current cases), rather than by the use of a special "0" value for the expiration date field, as in the DatedStockItem input file.
3. This function calls istream::fail() to determine whether the program has attempted to read more information from the input file than it contains (or if any other error has occurred when trying to read from the input file). If such an error occurs, the operator >> function assigns a default-constructed HomeItem to the reference argument Item and returns to the calling function immediately.
4. The local variables Artist, TrackCount, and Track are created only when the function needs them (for a "Music" object) rather than at the beginning of the function as has been our practice until now.
5. In the case of a "Music" object, one of those local variables is a Vec of strings.
6. The index variable i is also created only when it is needed, at the beginning of the