CISC181, Spring 2006, Project 3

Introduction

In this project, you build on project 2, using linked lists embedded in classes

In this project you will first work through some source code examples provided by the instructor to understand how to work with linked lists with classes. This code will be explained in lecture.

Then, you will adapt your project 2 code to use classes, following the examples provided.

Step 0: Work through the code in the proj3 subdirectory

There is nothing to turn in for this step.

Under this directory, there are several sub-directories. Each of which contains a later stage in the development of this code. Try to understand what is happening at each stage. At some stages, the code does not compile. Try to understand why. If the code doesn't compile, a later version will fix the error. Try to understand why the change fixed the problem.

Step 1: Adapt the code in step0/v9 to your topic
(Filenames: xxxx.h, xxxx.cc, etc. , 20% of total points, 20% complete when done)

Following the example in the step0/v9 directory, create the following files:

• A file called xxxx.h which defines a class. Instead of xxxx, you should use a name that relates to your topic, so that your file is named something like hikingTrail.h, or skiResort,h, jessicaSimpsonAlbum.h, i.e. a singular noun that describes one "record" in the datafile you used for Project 2.
• A file called xxxxList.h which defines c class for a "list of xxxxs", e.g. hikingTrailList.h, skiResortList.h, jessicaSimpsonDiscography.h (note that in the latter case, where there is a well-defined term for a list of albums, it makes sense to use it.)
• Files xxxx.cc and xxxxList.cc which contain the member functions for these two classes
• A main program that tests the classes you created, similar to the main program in step0/v9.

Step 2: Adapt the code from proj2 to use your class files
(Filenames: xxxx.h, xxxx.cc, etc. , 50% of total points, 70% complete when done)

Rewrite your project 2 code to use the object-oriented approach to linked lists (i.e. linked lists embedded in classes) illustrated in step0/v9.

This stage is worth 50 points; five points per menu option that works, as per the table below:

Submission:

If you are stopping at this stage, turn in a tar file that contains no .o or executable files; only your source code (.h and .cc files), your data file (e.g. xxxx.dat) and a Makefile that includes a make all and make clean rule.

Also, if you are stopping at this stage, create a script p2s2.txt that fully demonstrates your code, and also does a cat of all related source files, data files read, and data files written.

A few words about the rest of the assignment (steps 3 through 7)

There are still a few key skills you must have to be ready for material in CISC220. That's why I'm basing the final 30% of the third project (3% of your final course grade) on those final concepts. I've put these in what I beleive to be their order of importance to your future success as a C++ programmer (most important to least) so that if you don't finish the entire assignment, you'll maximize the effectiveness of the time you spend.

So, to earn a higher grade for project 3, you need to just add five simple things to your work so far:

For a class with pointers to attributes allocated from the heap, demonstrate that you know how to:

1. Correctly implement a copy constructor
2. Correctly overload the assignment operator
3. Correctly implement a destructor.

Then, two skills that are important, but don't really depend on whether the class has pointers or not:

4. Demonstrate that you understand how to overload the << operator for output. The << operator must be overloaded as a non-member function.
5. Demonstrate that you understand how to overload a binary + operator as a member function. (Note: You must do (1) and (2) correctly first, or this won't work right.)

If you can do all of these things, plus what you did in step 2, you've got the basics of C++ classes down. There are still many new concepts to learn—such as inheritance, multiple inheritance, virtual functions and polymorphism—but you can learn those as and when you need them. In my experience it is the concepts in the list above that create the MOST trouble for C++ students, not the fancier stuff, and so that is where I'm putting the emphasis.

I'll walk you through it with examples, step by step. In each case, I'm showing you what you would have to do in the context of the Acct_C and AcctList_C model classes you saw in steps 0-2, and in some cases with other classes as well. Your job is to understand the examples, and then "do likewise" with your code from the previous steps.

Here's an overview of the rest project. Each of the step names below is a "link" to that step.

• Step 3 : 5% (total of 75%) Correctly implement the copy constructor.
• Step 4 : 5% (total of 80%) Correctly implement the overloaded = operator.
• Step 5 : 5% (total of 85%) Correctly implement the destructor.
• Step 6 : 5% (total of 90%) Correctly overload the << operator for the "item" class.
• Step 7 : 5% (total of 95%) Correctly overload a binary + operator as a member function.
• Final Submission: 5% (total of 100%) Correctly submit all of the above via WebCT and via paper printout (unless your TA tells you he/she doesn't want a paper copy).

Step 3: Correctly implement the copy constructor for each class
(5% of total points, 75% complete when done)

Look at the example code in the proj3/step3 directory on the course web site. You'll see two directories, both containing code based on the Acct_C and AcctList_C examples from step 0. Look at the main program, which is the same in both directories. This main program relies on the copy constructor. If the copy constructor doesn't work properly, the program won't produce correct output.

Now compare the two .h files for the AcctList_C class from the two directories. You'll see that in one case, the copy constructor is overloaded, and in the other case it isn't. If you run the main from the directory without the overloaded copy constructor, you'll get wrong output. If you run the main from the directory with the overloaded copy constructor, you'll get good output. It's that simple.

How do you overload the copy constructor?

First, figure out the function prototype you need and add it to the .h file for each of your classes. Here are some examples:

Time_C(const Time_C &orig); 

Acct_C(const Acct_C &orig); 

AcctList_C(const AcctList_C &orig); 

Second, write the body of the function inside the .cc file. The body of the function needs to initalize the data members of the newly constructed object to be a complete copy of the object referred to by the parameter "orig". See the example code for details, as well as examples from your textbook.

How do you demonstrate that it works?

Look at the main program in the example directories acctListNoOverloadCopyConstructor and acctListOverloadCopyConstructor. You'll see that both directories contain exactly the same main program. What this main program does is to create an instance of class AcctList_C called acctList1. It then uses the copy constructor to make a new copy of that object called acctList2. It prints out both of these to show that they are the same. Then it makes a change to each object—adding "Carter" to acctList1 and "Reagan" to acctList2.

Compile and run both examples. In the example without the copy constructor, we see that the two objects aren't really independent; they are "joined at the heap". In fact, only the pointers were copied, so both acctList1 and acctList2 start out with the same values for head and tail. This means that both Carter and Reagan get added on to the same tail element (i.e. they get added after Ford.) The output that is produced is wrong.

In the example with the copy constructors (note that we have copy constructors for both the Acct_C and AcctList_C classes) the output is correct.

You need to write a separate main program that works in a similar way for your class. This is just a small main program to test that your copy constructor is working. It doesn't have to be a "practical, useful" program like p2s2.cc; its purpose is just to test your new member function.

In the p3s3.cc program, you don't need to read the items from a file; you can add them directly in the main program, as in the example here.

If you this is as far as you get, skip to the "final submission" step for instructions about what to put in your script.

Step 4: Correctly implement the overloaded = operator
(5% of total points, 80% complete when done)

Time_C t1(13,25); // 1:25pm
Time_C t2(t1); // make t2 same as t1
Time_C t3 = t1 // make t3 same as t1 

Time_C t1(13,25); // 1:25pm
Time_C t2;
Time_C t3;
t2 = t1;
t3 = t1;

Time_C & operator =(const Time_C &right); 

Acct_C & operator = (const Acct_C &right); 

AcctList_C & operator = (const AcctList_C &right); 

Time_C & Time_C::operator =(const Time_C &right) 
{
...

Acct_C & Acct_C::operator = (const Acct_C &right)
{
...

AcctList_C & AcctList_C::operator = (const AcctList_C &right)
{
...

For each of these functions you want to be sure that you do four things. See the example code for step 4 further explanation and example code.

1. Test for self-assignment (return *this if a self-assignment is taking place)
2. Recycle any old memory from the heap for the object on the left hand side of the assignment (*this).
3. Create the new deep copy and set the attributes of (*this) to point to it
4. Return (*this) as the result of the function.

How do you demonstrate that it works?

The programs in the step 4 directory illustrate what happens when overload assignment does and does not work. Look at main3.cc and model your test after that.

If you this is as far as you get, skip to the "final submission" step for instructions about what to put in your script.

Step 5: Correctly implement the destructor.
(5% of total points, 85% complete when done)

~Time_C(); 

~Acct_C(); 

~AcctList_C(); 

Time_C::~Time_C()
{
...
}
 

How do you demonstrate that it works?

Any time a constructor is invoked, a matching call to the destructor is automatically inserted at the point where that object goes out of scope. So, you don't have to do anything particularly special to make sure the destructor is getting called.

On the other hand, really showing through testing that a destructor is doing the right thing is difficult. If your program seg faults, its very possible you didn't do it right. If it doesn't, it might mean you did it right, or it might mean you just got lucky. For this assignment, we'll have to rely on the TAs to just look at your code and make sure you did it right.

If you are curious, you can look at the main for this step and turn on debugging (look in the Makefile for the -DDEBUG definition) to see where the destructor is getting called.

Step 6: Correctly overload the << operator for your "item" class.
(5% of total points, 90% complete when done)

Foo_C x,y;
cout << "x= ";
x.print(cout);
cout << " y= ";
y.print(cout);
cout << endl;

Foo_C x,y;
cout << "x= " << x << " y= " << y << endl;
 

std::ostream & operator << (std::ostream & left, const Time_C & right);

std::ostream & operator << (std::ostream & left, const Acct_C & right);

std::ostream & operator << (std::ostream & left, const AcctList_C & right);

void print(std::ostream & out ) const; 

ostream & operator << (ostream & left, const Foo_C & right)
{
   right.print(left);
   return left;
}

If your print function is called something other than print(), or doesn't take an ostream & as a parameter, you might have to make adjustments. See the sample code for step 4 for hints.

Step 7: Overload the binary + operator as a member function
(5% of total points, 95% complete when done)

Overloading the + operator for a class allows you to use the + operator on objects of that class, as in the following example. (The full source code for this example can be found in the proj3 subdirectory under step7.)

  Time_C start(13,25); // start time is 1:25pm
  Duration_C howLong(0,50); // class lasts 50 minutes
  Time_C end = start + howLong; // class ends at 2:15pm
  cout << "end = "; end.print(); cout << endl;
 

If you don't overload the + operator, you get a syntax error if you try to use the + operator in this way.

> make main
CC    -o main main.cc 
"main.cc", line 13: Error: The operation "Time_C + Duration_C" is illegal.
1 Error(s) detected.
*** Error code 1
make: Fatal error: Command failed for target `main'
>

However, if you do overload the operator, then this works just fine:

> make
CC    -c  main.cc
CC    -c  time.cc
CC -o main main.o time.o
> ./main
end = 2:15pm
>

This make the most sense when the objects you are manipulating represent some kind of number: e.g. amounts of money or time, or mathematical objects that can be added such as sets, complex numbers, and polynomials. However, the plus operator can be overloaded for any class; in one sense, it is just a different syntax for a function call.

For example, instead of the syntax:

acctList.addAccount(x);
 

we could write instead:

acctList = acctList + x;

Some things to note:

• The line of code acctList = acctList + x; also requires that the copy constructor and assignment operator work properly. The copy constructor is used to return the value of the operator+ function, and the operator= is used to copy the value of the right hand side of the assignment to the left hand side of the assignment. For classes involving pointers to storage on the heap, this means you need to overload those two operators first. If default memberwise copy does the right thing (as with the Time_C and Duration_C classes in the example earlier) then this is a non-issue.
  
• You might wonder if you can write

  acctList += x;

  instead of the line of code above. You can, but to do so, you must overload the += operator. Overloading + and = separately doesn't give you += for free; you have to do it separately.
  
• Is writing acctList = acctList + x; better than writing acctList.addAccount(x); in any fundamental way?
  
  That's a matter of opinion. The designer of Java didn't think so, and left operator overloading out of the language, making the language that little bit less complicated.
  
  The designer of C++ felt that operator overloading was useful, in that it made user defined objects "first class citizens" of the language in every sense; provided the proper operators were overloaded, user defined classes and built in types could be used the same way. For programs involving mathematical formulas, it is a lot cleaner to use familar operators than a series of function calls.

First, figure out the function prototype you need and add it to the .h file for the class. Here's how:

Realize that when a binary operator is overloaded as a member function, the function prototype has only one argument, which is the right operand of the + sign. That argument is passed as const reference (e.g. const Acct_C & right). The left operand of the + sign MUST be an object of the same type as the class you are making the member function a part of. It can be accessed via the this pointer.

So here are some examples:

Time_C start(1,25);
Duration_C howLong(0,50);
Time_C end;
end = start + howLong;

const Time_C operator+(const Duration_C &right);

AcctList_C acctList1; 
Acct_C democrat(102, "Clinton");
Acct_C republican(103, "Reagan");
acctList1 = acctList1 + democrat;
acctList1 = acctList1 + republican; 

AcctList_C operator+(const Acct_C & right); 

Whether the returned type should be const or non-const, and whether it should be a reference or a value is a matter of debate. For purposes of this project I'll accept anything that works.

The sample code for step 5 shows a few approaches to writing the body of an overloaded + operator; consult these for ideas.

Final Submission:
(5% of total points, 100% complete when done)