PIC 10b Fall 2000 HW #2
Homework FAQ.
Solution Set.
Due date: Oct. 18. Lecture 1's due time is: 10:30pm
========= Lecture 2's due time is: 5:30pm.
Reading Assignment: Read Sedgewick Ch1 to Ch3 Sec 3.
===================
Files to submit: pic10bhw2file1.h -contains Set interface
================= pic10bhw2file2.cpp -contains Set class implementation
pic10bhw2file3.cpp -contains driver program i.e., main()
HW2 Purpose: Write a dynamic storage class called Set.
============ Practice with separate compilation of files.
Gain experience with operator overloading and
dynamic memory allocation. Learn a little
bit about analyzing amortized run time of an
algorithm.
Specification:
==============
The Set class has three private variables:
int *array; // stores user data
int curSize; // storage space used
int maxSize; // current total storage space.
Below are the public member functions for and friends of Set:
Set(); // constructor. array set to be a new array of ints of size 10
// curSize is set to 0; maxSize set to 10
Set(int s); //constructor. array set to be a new array of ints of size s
// curSize is set to 0; maxSize is set to s.
Set(const Set& s); //constructor. copies s into current object
~Set(); //destructor should free up memory in *array
Set& operator=(Set& v); //should use this pointer to check if
//v is current object. If it is
//return current object. Otherwise,
//set up current object as in v and
//return current object.
//member function not friend!
friend Set operator+(const Set& s, int m); //returns the Set that results from
//adding m to s.
friend Set operator+(int m, const Set& s); //returns the Set that results from
//adding m to s (does same as
//previous function)
//For the previous two functions if s's curSize < maxSize then
//the Set returned by + has the same maxSize as s but curSize is incremented.
//On the other hand, if curSize = maxSize then the Set returned
//has curSize one larger, but maxSize twice as large as s.
//When allocating memory for array in the new Set make it of size this
//new maxSize.
bool element(int i); //checks if the integer i has been stored in the Set.
// returns true if it has; false otherwise.
friend ostream& operator << (ostream& out, const Set& s);
//prints each element to ostream&
//separated by a return
friend istream& operator >> (istream& in, Set& s);
//reads one integer element
//and stores it into set s using
//+ operator.
You should also write a driver program as below:
The driver should first should create two sets:
Set *s1, *s2;
s1 = new Set();
s2 = new Set(1);
It should then set
*s1 = *s2 +1;
*s1 = *s1;
*s2 = 2 + *s1;
It should check if 2 is an element of s1 and print out result using cout.
It should check if 2 is an element of s2 and print out result using cout.
It should read two more elements into s2 using cin >> *s2 >> *s2;
Finally it should print out the elements of s2 using cout << *s2 and then
delete s1 and s2 and return 0.
Point Breakdown for HW2
=======================
If the submit program didn't collect your file
because you misnamed it or you did not follow
the required formatting instructions in the syllabus
you will get a 0 without an opportunity for a regrade.
If your driver program doesn't test something as described above,
then you won't receive credit for it.
How well your code is commented.........1pt.
use #ifndef in header file..............1pt.
class def in header has member and
friend functions as specified above.1pt.
constructors and destructors work
correctly................1pt.
Set + int and int + Set work
correctly................1pt.
= is overloaded and uses the "this"
pointer correctly...............1pt.
element(i) method works correctly.......1pt.
<< and >> overloaded and work
correctly............................1pt.
============================================
Total...................................8pts
Bonus...................................1pt.(after curving on final grade)
Bonus: Implement the following two additional member function and friend
====== function and write additional driver routine to test them:
Set& operator+=(int elt); // adds elt to current Set using same
// algorithm for resizing array as stated above
//returns reference of current set.
//Only does copying when need to resize.
friend bool operator==(const Set& s1, const Set& s2);
// tests if two sets are the same.
// They are the same if have same elements.
// It doesn't matter if they have same number of
// copies of a given element. i.e., {1,2} and {1,2,1}
// are same.
|