//Project36.cpp
//Date 12/07/2001
//Commented code removed
//Author: Us
////////////////////////////////////////////////////
//includes
////////////////////////////////////////////////////
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
////////////////////////////////////////////////////
// constants
////////////////////////////////////////////////////
const int MAX_LEN = 20;
const int UNDEFINED = -99;
const char *testNames[] =
{
"Chair", "Table", "Spoon", "Knife",
"Phone", "Couch", "Drive", "Mouse",
"Clock", "Cable", "Plier", "Paper",
"Stand", "Stool"
};
const int testWeights[] =
{
11, 22, 33, 44, 55, 66,
77, 88, 99, 12, 13, 14,
15, 16
};
const int MAX_NAMES = sizeof(testNames)/sizeof(testNames[0]);
const int MAX_ITEMS = 20;
////////////////////////////////////////////////////
// test functions
////////////////////////////////////////////////////
void testInput(void);
void testConstructor(void);
void testConstructorCh(void);
void testConstructorCopy(void);
void testSetName(void);
void testSetWeight(void);
void testSet(void);
void testOperatorEqual(void);
void testGetName(void);
void testGetWeight(void);
void testOperatorLessThan(void);
void testOperatorAssign(void);
void testOperatorInsertion(void);
void testOperatorExtraction(void);
void testConstructorCDInventory(void);
void testConstructor2CDInventory(void);
void testConstructor3CDInventory(void);
void testOperatorAssignCDInventory(void);
void testInsertCDInventory(void);
void testCopyConstructorCDInventory(void);
void testOperatorEqualCDInventory(void);
void testOperatorLessThanOrEqual(void);
void testOperatorGreaterThan(void);
void testOperatorGreaterThanOrEqual(void);
void testMergeCDInventory(void);
////////////////////////////////////////////////////
// CDItem class
////////////////////////////////////////////////////
class CDItem
{
private:
char m_name[MAX_LEN+1];
int m_weight;
CDItem* m_next;
public:
CDItem(void);
CDItem(char name[], int weight);
CDItem(char ch);
CDItem(const CDItem &item);
CDItem* addOfNext(void)
{
return m_next;
}
void input(void);
void display(void) const;
void set(char name[], int weight);
void setName(char name[]);
void setWeight(int weight);
char * getName(void);
int getWeight(void);
bool operator < (const CDItem &i2);
bool operator <= (const CDItem &i2);
bool operator > (const CDItem &i2);
bool operator >= (const CDItem &i2);
CDItem & operator = (const CDItem &i2);
friend bool operator ==(const CDItem &i1, const CDItem &i2);
friend ostream & operator << (ostream &bob, const CDItem &item);
friend istream & operator >> (istream &joe, CDItem &item);
friend class CDInventory;
};
////////////////////////////////////////////////////
// CDInventory class
////////////////////////////////////////////////////
class CDInventory
{
private:
int m_count;
CDItem *m_ptr;
void swap(CDItem &i1, CDItem &i2)
{
CDItem tempItem;
tempItem = i1;
i1 = i2;
i2 = tempItem;
};
void removeAll(void);
public:
CDInventory(void);
CDInventory(int n);
CDInventory(char ch);
CDInventory(const CDInventory &inv);
~CDInventory(void);
bool insert(const CDItem &item);
int merge(const CDInventory &inv2);
CDInventory & operator = (const CDInventory &inv2);
bool operator == (const CDInventory &inv2) const;
friend ostream & operator << (ostream &bob, const CDInventory &inv);
friend istream & operator >> (istream &joe, CDInventory &inv);
};
////////////////////////////////////////////////////
// main function
////////////////////////////////////////////////////
void main(void)
{
srand((unsigned)time(NULL));
//testInput();
//testConstructor();
//testConstructorCh();
//testConstructorCopy();
//testSetName();
//testSetWeight();
//testSet();
//testOperatorEqual();
//testGetName();
//testGetWeight();
//testOperatorLessThan();
//testOperatorAssign();
//testOperatorInsertion();
//testOperatorExtraction();
//testConstructorCDInventory();
//testConstructor2CDInventory();
//testConstructor3CDInventory();
//testOperatorAssignCDInventory();
//testInsertCDInventory();
//testCopyConstructorCDInventory();
//testOperatorEqualCDInventory();
//testOperatorLessThanOrEqual();
//testOperatorGreaterThan();
//testOperatorGreaterThanOrEqual();
testMergeCDInventory();
}
////////////////////////////////////////////////////
// int CDInventory::merge(const CDInventory &inv2)
////////////////////////////////////////////////////
int CDInventory::merge(const CDInventory &inv2)
{
CDItem *p;
p = inv2.m_ptr;
while (p != NULL)
{
this->insert(*p);
p = p->addOfNext();
}
return inv2.m_count;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testMergeCDInventory(void);
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testMergeCDInventory(void)
{
for (int i=1; i<=10; i++)
{
CDInventory inv1(rand()%MAX_ITEMS/2);
CDInventory inv2(rand()%MAX_ITEMS/2);
cout << "inv1 =\n";
cout << inv1 << endl;
cout << "inv2 =\n";
cout << inv2 << endl;
int j = inv1.merge(inv2);
cout << "After j = inv1.merge(inv2);\n";
cout << "j = " << j << endl;
cout << "inv1 =\n";
cout << inv1 << endl;
cout << "inv2 =\n";
cout << inv2 << endl;
cout << "-----------------------------------\n";
}
}
////////////////////////////////////////////////////
// bool CDInventory::operator == (const CDInventory &inv2)
////////////////////////////////////////////////////
bool CDInventory::operator == (const CDInventory &inv2) const
{
if (this->m_count != inv2.m_count)
return false;
CDItem *p1, *p2;
for (p1=this->m_ptr, p2=inv2.m_ptr; p1!=NULL; p1=p1->addOfNext(), p2=p2->addOfNext())
if (!(*p1 == *p2))
return false;
return true;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorEqualCDInventory
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorEqualCDInventory(void)
{
cout << "testOperatorEqualCDInventory\n";
cout << "----------------------------\n";
for (int i=1; i<=2; i++)
{
CDInventory myInv('r');
CDInventory yourInv(myInv);
cout << myInv << endl;
cout << yourInv << endl;
if (myInv == yourInv)
cout << "Are equal\n";
else
cout << "Are NOT equal\n";
}
}
////////////////////////////////////////////////////
// CDInventory::CDInventory(const CDInventory &inv)
////////////////////////////////////////////////////
CDInventory::CDInventory(const CDInventory &inv)
{
cout << "Copy constructor called\n";
CDInventory tempInv;
CDItem *p;
for (p=inv.m_ptr; p!=NULL; p = p->addOfNext())
tempInv.insert(*p);
this->m_ptr = NULL;
this->m_count = 0;
for (p=tempInv.m_ptr; p!=NULL; p = p->addOfNext())
this->insert(*p);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testCopyConstructorCDInventory
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testCopyConstructorCDInventory(void)
{
cout << "testCopyConstructorCDInventory\n";
cout << "-----------------------------\n";
for (int i=1; i<=2; i++)
{
CDInventory myInv('r');
CDInventory yourInv(myInv);
cout << "myInv = \n";
cout << myInv << endl;
cout << "yourInv = \n";
cout << yourInv << endl;
if (myInv == yourInv)
cout << "Worked\n";
else
cout << "DID NOT WORK\n";
}
}
////////////////////////////////////////////////////
// CDInventory::~CDInventory(void)
////////////////////////////////////////////////////
CDInventory::~CDInventory(void)
{
this->removeAll();
}
////////////////////////////////////////////////////
// void CDInventory::removeAll(void)
////////////////////////////////////////////////////
void CDInventory::removeAll(void)
{
CDItem *p;
while (this->m_ptr != NULL)
{
p = this->m_ptr;
m_ptr = m_ptr->addOfNext();
delete p;
}
this->m_count = 0;
}
////////////////////////////////////////////////////
// bool CDInventory::insert(const CDItem &item)
////////////////////////////////////////////////////
/*insert item to inventory
if count = MAX_ITEMS then return false
items[count] = item
count++
return true
*/
////////////////////////////////////////////////////
bool CDInventory::insert(const CDItem &item) //11/02/2001
{
CDItem *p;
p = new CDItem(item);
if (NULL == p)
return false;
p->m_next = this->m_ptr;
this->m_ptr = p;
this->m_count++;
return true;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testInsertCDInventory
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testInsertCDInventory(void)
{
cout << "testInsertCDInventory\n";
cout << "=====================\n";
for (int i=0; i<=5; i++)
{
CDInventory *invPtr;
invPtr = new CDInventory;
for (int j=0; j<5; j++)
{
cout << "Original\n";
cout << *invPtr;
CDItem item('r');
if(invPtr->insert(item))
cout << "success\n";
else
cout << "OVERFLOW\n";
cout << "After inserting " << item;
cout << *invPtr;
cout << "-------------------\n";
}
delete invPtr;
}
}
////////////////////////////////////////////////////
// operator =
////////////////////////////////////////////////////
CDInventory & CDInventory::operator = (const CDInventory &inv2)
{
CDInventory tempInv;
CDItem *p;
p = inv2.m_ptr;
while (p != NULL)
{
tempInv.insert(*p);
p = p->addOfNext();
}
this->removeAll();
p = tempInv.m_ptr;
while (p != NULL)
{
this->insert(*p);
p = p->addOfNext();
}
return *this;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorAssignCDInventory
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorAssignCDInventory(void)
{
cout << "testOperatorAssignCDInventory\n";
cout << "=============================\n";
for (int i=1; i<=2; i++)
{
CDInventory yourInv('r');
CDInventory myInv('R');
CDInventory hisInv('r');
cout << "yourInv = " << yourInv << endl;
cout << "myInv = " << myInv << endl;
cout << "hisInv = " << hisInv << endl;
yourInv = myInv = hisInv;
cout << "After yourInv = myInv = hisInv;\n";
cout << "yourInv = " << yourInv << endl;
cout << "myInv = " << myInv << endl;
cout << "hisInv = " << hisInv << endl;
cout << "----------------------\n";
}
}
////////////////////////////////////////////////////
// construct inventory of random random items
////////////////////////////////////////////////////
CDInventory::CDInventory(char ch)
{
this->m_ptr = NULL;
this->m_count = 0;
if (('r' == ch) || ('R' == ch))
{
int n = rand()%MAX_ITEMS;
for (int i=0; i<n; i++)
{
CDItem item('r');
this->insert(item);
}
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testConstructor3CDInventory
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testConstructor3CDInventory(void)
{
cout << "testConstructor3CInventory\n";
cout << "=========================\n";
for (int i=1; i<=5; i++)
{
CDInventory yourInv('r');
CDInventory myInv('R');
CDInventory hisInv('s');
cout << yourInv;
cout << endl;
cout << myInv;
cout << endl;
cout << hisInv;
cout << "-------------------\n";
}
}
////////////////////////////////////////////////////
// construct inventory of n random items
////////////////////////////////////////////////////
CDInventory::CDInventory(int n)
{
if (n < 0)
n = -n;
this->m_count = 0;
this->m_ptr = NULL;
for (int i=0; i<=n-1; i++)
{
CDItem item('r');
this->insert(item);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testConstructor2CInventory
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testConstructor2CDInventory(void)
{
cout << "testConstructor2CDInventory\n";
cout << "===========================\n";
for (int i=-1; i<=5; i++)
{
CDInventory yourInv(i);
cout << yourInv;
cout << "-------------------\n";
}
}
////////////////////////////////////////////////////
// operator << overloaded for CDInventory
////////////////////////////////////////////////////
ostream & operator << (ostream &bob, const CDInventory &inv)
{
bob << "inventory(" << inv.m_count << ")=\n";
CDItem * p;
p = inv.m_ptr;
while (p != NULL)
{
bob << *p;
p = p->addOfNext();
}
return bob;
}
////////////////////////////////////////////////////
// default constructor for CDInventory
////////////////////////////////////////////////////
CDInventory::CDInventory(void)
{
this->m_count = 0;
this->m_ptr = NULL;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testConstructorCInventory
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testConstructorCDInventory(void)
{
cout << "testConstructorCDInventory\n";
cout << "==========================\n";
for (int i=1; i<=5; i++)
{
CDInventory yourInv;
cout << yourInv;
cout << "-------------------\n";
}
}
////////////////////////////////////////////////////
//overload >> for CDItem
////////////////////////////////////////////////////
istream & operator >> (istream &joe, CDItem &item)
{
cout << "item m_name: ";
joe >> item.m_name;
cout << "item m_weight: ";
joe >> item.m_weight;
return joe;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// test operator >>
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorExtraction(void)
{
cout << "Test operator >>\n";
cout << "=================\n";
for (int i=1; i<=5; i++)
{
CDItem item1;
cin >> item1;
cout << item1;
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
//overload << for CDItem
////////////////////////////////////////////////////
ostream & operator << (ostream &bob, const CDItem &item)
{
bob << '[' << item.m_name << ", ";
bob << item.m_weight << ']' << endl;
return bob;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// test operator <<
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorInsertion(void)
{
cout << "Test operator <<\n";
cout << "=================\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r');
cout << "item1 = "; item1.display();
cout << "item1 = " << item1 << endl;
cout << item1 << item1;
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// operator = overloaded
////////////////////////////////////////////////////
CDItem & CDItem::operator = (const CDItem &i2)
{
strcpy(m_name, i2.m_name);
this->m_weight = i2.m_weight;
return *this;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorAssign
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorAssign(void)
{
cout << "Test operator =\n";
cout << "===============\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r'), item2('r'), item3('r');
cout << "item1 = "; item1.display();
cout << "item2 = "; item2.display();
cout << "item3 = "; item3.display();
item1 = item2 = item3;
cout << "After item1 = item2 = item3;\n";
cout << "item1 = "; item1.display();
cout << "item2 = "; item2.display();
cout << "item3 = "; item3.display();
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// operator >= overloaded for CDItem class objects
// returns true if weight of i1 is >= that of i2
// else returns false
////////////////////////////////////////////////////
bool CDItem::operator >= (const CDItem &i2)
{
return !(*this < i2);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorGreaterThanOrEqual
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorGreaterThanOrEqual(void)
{
cout << "Test operator >=\n";
cout << "================\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r'), item2('r'), item3('r');
cout << "item1 = "; item1.display();
cout << "item2 = "; item2.display();
cout << "item3 = "; item3.display();
if (item1 >= item2)
cout << "item1 is >= item2\n";
else
cout << "item1 is not >= item2\n";
if (item1 >= item3)
cout << "item1 is >= item3\n";
else
cout << "item1 is not >= item3\n";
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// operator > overloaded for CDItem class objects
// returns true if weight of i1 is > that of i2
// else returns false
////////////////////////////////////////////////////
bool CDItem::operator > (const CDItem &i2)
{
return (this->m_weight > i2.m_weight);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorGreaterThan
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorGreaterThan(void)
{
cout << "Test operator >\n";
cout << "===============\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r'), item2('r'), item3('r');
cout << "item1 = "; item1.display();
cout << "item2 = "; item2.display();
cout << "item3 = "; item3.display();
if (item1 > item2)
cout << "item1 is > item2\n";
else
cout << "item1 is not > item2\n";
if (item1 > item3)
cout << "item1 is > item3\n";
else
cout << "item1 is not > item3\n";
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// operator <= overloaded for CDItem class objects
// returns true if weight of i1 is <= that of i2
// else returns false
////////////////////////////////////////////////////
bool CDItem::operator <= (const CDItem &i2)
{
return (this->m_weight <= i2.m_weight);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorLessThanOrEqual
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorLessThanOrEqual(void)
{
cout << "Test operator <=\n";
cout << "================\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r'), item2('r'), item3('r');
cout << "item1 = "; item1.display();
cout << "item2 = "; item2.display();
cout << "item3 = "; item3.display();
if (item1 <= item2)
cout << "item1 is <= item2\n";
else
cout << "item1 is not <= item2\n";
if (item1 <= item3)
cout << "item1 is <= item3\n";
else
cout << "item1 is not <= item3\n";
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// operator < overloaded for CDItem class objects
// returns true if weight of i1 is less than that of i2
// else returns false
////////////////////////////////////////////////////
bool CDItem::operator < (const CDItem &i2)
{
return (this->m_weight < i2.m_weight);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorLessThan
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorLessThan(void)
{
cout << "Test operator <\n";
cout << "===============\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r'), item2('r'), item3('r');
cout << "item1 = "; item1.display();
cout << "item2 = "; item2.display();
cout << "item3 = "; item3.display();
if (item1 < item2)
cout << "item1 is lighter than item2\n";
else
cout << "item1 is not lighter than item2\n";
if (item1 < item3)
cout << "item1 is lighter than item3\n";
else
cout << "item1 is not lighter than item3\n";
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// getWeight
// returns the weight
////////////////////////////////////////////////////
int CDItem::getWeight(void)
{
return this->m_weight;
};
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testGetWeight
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testGetWeight(void)
{
cout << "test getWeight\n";
for (int i=1; i<=5; i++)
{
CDItem i('r');
cout << "item = "; i.display();
cout << "weight = " << i.getWeight() << endl;
cout << "-----------------------------\n";
}
}
////////////////////////////////////////////////////
// getName
// returns the name
////////////////////////////////////////////////////
char * CDItem::getName(void)
{
return this->m_name;
};
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testGetName
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testGetName(void)
{
cout << "test getName\n";
for (int i=1; i<=5; i++)
{
CDItem i('r');
cout << "item = "; i.display();
cout << "name = " << i.getName() << endl;
cout << "-----------------------------\n";
}
}
////////////////////////////////////////////////////
// operator ==
// compares two items for equality
////////////////////////////////////////////////////
bool operator ==(const CDItem &i1, const CDItem &i2)
{
if (i1.m_weight != i2.m_weight)
return false;
if (strcmp(i1.m_name, i2.m_name) != 0)
return false;
return true;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testOperatorEqual
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testOperatorEqual(void)
{
cout << "Test operator equal\n";
cout << "===================\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r'), item2('r'), item3(item1);
cout << "item1 = "; item1.display();
cout << "item2 = "; item2.display();
cout << "item3 = "; item3.display();
if (item1 == item2)
cout << "item1 is equal to item2\n";
else
cout << "item1 is not equal to item2\n";
if (item1 == item3)
cout << "item1 is equal to item3\n";
else
cout << "item1 is not equal to item3\n";
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// setWeight(int weight)
// sets the m_weight data member to weight
////////////////////////////////////////////////////
void CDItem::setWeight(int weight)
{
this->m_weight = weight;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testSetWeight
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testSetWeight(void)
{
cout << "Test setWeight(weight)\n";
for (int i=1; i<=5; i++)
{
CDItem item('r');
item.display();
int tWeight = rand()%100;
cout << "tWeight = " << tWeight << endl;
item.setWeight(tWeight);
cout << "After item1.setWeight(tWeight);\n";
item.display();
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
// setName(char name)
// sets the m_name data member to name
////////////////////////////////////////////////////
void CDItem::setName(char name[])
{
strcpy(this->m_name, name);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testSetName
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testSetName(void)
{
cout << "Test setName(name)\n";
for (int i=1; i<=5; i++)
{
CDItem item('r');
item.display();
int i = rand()%MAX_NAMES;
char tName[MAX_LEN+1];
strcpy(tName, testNames[i]);
cout << "tName = \"" << tName << "\"" << endl;
item.setName(tName);
cout << "After item1.setName(tName);\n";
item.display();
cout << "---------------------------\n";
}
}
////////////////////////////////////////////////////
//CDItem (item) copy constructor
// constructs an object which is a copy given object
////////////////////////////////////////////////////
CDItem::CDItem(const CDItem &item)
{
strcpy(this->m_name, item.m_name);
this->m_weight = item.m_weight;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testConstructorCopy
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testConstructorCopy(void)
{
cout << "Test copy Constructor\n";
for (int i=1; i<=5; i++)
{
CDItem item1('r');
CDItem item2(item1);
item1.display();
item2.display();
}
}
////////////////////////////////////////////////////
//CDItem (ch) constructor
// constructs an object with random name and weight
////////////////////////////////////////////////////
CDItem::CDItem(char ch)
{
if ('r' == ch )
{
int i = rand()%MAX_NAMES;
strcpy(this->m_name, testNames[i]);
this->m_weight = testWeights[i];
}
else
{
strcpy(this->m_name, "");
this->m_weight = -99;
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testConstructorCh
//++++++++++++++++++++++++++++++++++++++++++++++++++
void testConstructorCh(void)
{
cout << "Test ConstructorCh\n";
CDItem item1('r');
CDItem item2('m');
item1.display();
item2.display();
}
////////////////////////////////////////////////////
//CDItem (name, weight) constructor
// constructs an object with given name and weight
////////////////////////////////////////////////////
CDItem::CDItem(char name[], int weight)
{
strcpy(this->m_name, name);
this->m_weight = weight;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testConstructor
//31++++++++++++++++++++++++++++++++++++++++++++++++
void testConstructor(void)
{
cout << "Test Constructor(name, weight)\n";
CDItem item("Chair", 150);
item.display();
}
////////////////////////////////////////////////////
// display
////////////////////////////////////////////////////
void CDItem::display(void) const
{
cout << '[' << this->m_name << ", ";
cout << this->m_weight << ']' << endl;
}
////////////////////////////////////////////////////
//constructor default
////////////////////////////////////////////////////
CDItem::CDItem(void)
{
strcpy(this->m_name, "");
this->m_weight = -99;
}
////////////////////////////////////////////////////
//input function
// This is a member function for CDItem class
// it gets the name and weight from the keyboard
// and sets the values of name and weight data members
////////////////////////////////////////////////////
void CDItem::input(void)
{
cout << "item m_name: ";
cin >> this->m_name;
cout << "item m_weight: ";
cin >> this->m_weight;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testInput
//31++++++++++++++++++++++++++++++++++++++++++++++++
void testInput(void)
{
cout << "test input function\n";
CDItem item1;
item1.display();
item1.input();
item1.display();
}
////////////////////////////////////////////////////
// set(name, weight)
////////////////////////////////////////////////////
void CDItem::set(char name[], int weight)
{
strcpy(this->m_name, name);
this->m_weight = weight;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++
// testSet
//31++++++++++++++++++++++++++++++++++++++++++++++++
void testSet(void)
{
cout << "Test set(name, weight)\n";
for (int i=1; i<=5; i++)
{
CDItem item('r');
item.display();
int i = rand()%MAX_NAMES;
char tName[MAX_LEN+1];
strcpy(tName, testNames[i]);
cout << "tName = \"" << tName << "\"" << endl;
int tWeight = rand()%100;
cout << "tWeight = " << tWeight << endl;
item.set(tName, tWeight);
cout << "After item.set(tName, tWeight);\n";
item.display();
cout << "------------------------------------\n";
}
}
|