// rect002.cpp
#include <iostream.h>
#include <stdlib.h>
#include <time.h>
/////////////////////////////////////////////////////////////////////
// Constant definitions
// length and width should be in [MIN_DIM, MAX_DIM]
/////////////////////////////////////////////////////////////////////
const int MIN_DIM = 1;
const int MAX_DIM = 19;
const int TEST_COUNT = 5;
/////////////////////////////////////////////////////////////////////
// CRectangle class definition
/////////////////////////////////////////////////////////////////////
class CRectangle
{
private:
int length;
int width;
public:
CRectangle(int len=1, int wid=1);
int perimeter(void) const;
int area(void) const; //p01
void setDimension(int len, int wid); //p01
void setLength(int len); //p01
void setWidth(int wid); //p01
int getLength(void) const; //p01
int getWidth(void) const; //p01
void getDimension(int &len, int &wid) const;//p01
void display(void) const;
int & badSet(void);
CRectangle(char ch);
~CRectangle(void);
friend bool isSquare(const CRectangle &rect);
};
/////////////////////////////////////////////////////////////////////
// isSquare function to check if a rectangle is square
/////////////////////////////////////////////////////////////////////
bool isSquare(const CRectangle &rect)
{
return (rect.length == rect.width);
}
/////////////////////////////////////////////////////////////////////
// testIsSquare
/////////////////////////////////////////////////////////////////////
void testIsSquare(void)
{
cout << "------------------\n";
cout << "testIsSquare(void)\n";
cout << "------------------\n";
for (int i=0; i<TEST_COUNT; i++)
{
char ch;
if (rand()%2 == 0)
ch = 'r';
else
ch = 's';
CRectangle rect1(ch);
rect1.display();
if (isSquare(rect1))
cout << "Is square\n";
else
cout << "Is NOT square\n";
}
}
/////////////////////////////////////////////////////////////////////
// ~CRectangle
// destructor for CRectangle
/////////////////////////////////////////////////////////////////////
CRectangle::~CRectangle(void)
{
cout << "Destructor called\n";
}
/////////////////////////////////////////////////////////////////////
//void testDestructor(void)
/////////////////////////////////////////////////////////////////////
void testDestructor(void)
{
cout << "--------------------\n";
cout << "testDestructor(void)\n";
cout << "--------------------\n";
{
CRectangle rect;
rect.display();
}
{
CRectangle *p;
p = new CRectangle;
p->display();
delete p;
}
{
cout << "Dynamic array of rectangles\n";
CRectangle *p;
p = new CRectangle[5];
p->display();
delete []p;
}
{
cout << "Static rectangle\n";
static CRectangle rect;
rect.display();
}
cout << "out of scope of static \n";
{
cout << "Static rectangle\n";
static CRectangle rect;
rect.display();
exit(1);
}
cout << "out of scope of static \n";
}
/////////////////////////////////////////////////////////////////////
// constructor with a character
// if character is 's' it builds a square
// 'r' it builds a random
/////////////////////////////////////////////////////////////////////
CRectangle::CRectangle(char ch)
{
if (('s'==ch) || ('S'==ch))
{
length = rand()%MAX_DIM+1;
width = length;
}
else if (('r'==ch) || ('R'==ch))
{
length = rand()%MAX_DIM+1;
width = rand()%MAX_DIM+1;
}
else
length = width = 1;
}
/////////////////////////////////////////////////////////////////////
// testConstructorRand(void)
/////////////////////////////////////////////////////////////////////
void testConstructorRand(void)
{
cout << "-------------------------\n";
cout << "testConstructorRand(void)\n";
cout << "-------------------------\n";
for (int i=0; i<TEST_COUNT; i++)
{
char ch;
switch (rand()%5)
{
case 0: ch = 'r'; break;
case 1: ch = 'R'; break;
case 2: ch = 's'; break;
case 3: ch = 'S'; break;
case 4: ch = 'k'; break;
default:ch = 'k';
}
CRectangle rect1(ch);
cout << "CRectangle rect1('" << ch << "'); => "; rect1.display();
}
}
/////////////////////////////////////////////////////////////////////
//badSet function
/////////////////////////////////////////////////////////////////////
int & CRectangle::badSet(void)
{
return length;
}
/////////////////////////////////////////////////////////////////////
// testBadSet(void)
/////////////////////////////////////////////////////////////////////
void testBadSet(void)
{
cout << "----------------\n";
cout << "testBadSet(void)\n";
cout << "----------------\n";
for (int i=0; i<TEST_COUNT; i++)
{
CRectangle r1('r');
r1.display();
r1.badSet()=99;
cout << "After r1.badSet()=99; ";
r1.display();
}
}
/////////////////////////////////////////////////////////////////////
// Test function for default constructor
/////////////////////////////////////////////////////////////////////
void testConstructorDefault(void)
{
cout << "----------------------------\n";
cout << "testConstructorDefault(void)\n";
cout << "----------------------------\n";
CRectangle r1;
r1.display();
CRectangle myRectangles[TEST_COUNT];
cout << "Using for loop:\n";
for (int i=0; i<TEST_COUNT; i++)
myRectangles[i].display();
cout << "Using pointer p, while loop, and p++:\n";
CRectangle *p;
p = myRectangles;
while (true)
{
p->display();
if (&myRectangles[TEST_COUNT-1] == p)
break;
p++;
}
cout << "Using pointer p, for loop, and (p+i)-> :\n";
p = &myRectangles[0];
for (i=0; i<TEST_COUNT; i++)
(p+i)->display();
cout << "Using pointer p, for loop, and (*(p+i)). :\n";
p = &myRectangles[0];
for (i=0; i<TEST_COUNT; i++)
(*(p+i)).display();
}
/////////////////////////////////////////////////////////////////////
// Constructor for CRectangle
// initializes the length and width with len and wid
// makes sure that the values are between MIN_DIM and MAX_DIM
// sets them to 1 if the the supplied values are out of range
/////////////////////////////////////////////////////////////////////
CRectangle::CRectangle(int len, int wid)
{
if ((len >= MIN_DIM) && (len <= MAX_DIM))
length = len;
else
length = 1;
if ((wid >= MIN_DIM) && (wid <= MAX_DIM))
width = wid;
else
width = 1;
}
/////////////////////////////////////////////////////////////////////
// Test function for constructor with given values for length & width
/////////////////////////////////////////////////////////////////////
void testConstructorWithDims(void)
{
cout << "-----------------------------\n";
cout << "testConstructorWithDims(void)\n";
cout << "-----------------------------\n";
for (int i=0; i<TEST_COUNT; i++)
{
int len = rand()%MAX_DIM + 1;
if (rand()%4 == 1)
len = len + MAX_DIM/2;
int wid = rand()%MAX_DIM + 1;
if (rand()%4 == 1)
wid = wid + MAX_DIM/2;
if (rand()%3 == 1)
len = -len;
if (rand()%3 == 1)
wid = -wid;
cout << "len = " << len << ", wid = " << wid << endl;
CRectangle rect(len, wid);
cout << "CRectangle rect(len, wid); => ";
rect.display();
}
}
/////////////////////////////////////////////////////////////////////
// testAssignmentDefault
/////////////////////////////////////////////////////////////////////
void testAssignmentDefault(void)
{
cout << "---------------------------\n";
cout << "testAssignmentDefault(void)\n";
cout << "---------------------------\n";
for (int i=0; i<TEST_COUNT; i++)
{
CRectangle rect1('r'), rect2('r'), rect3('r');
cout << "rect1 = "; rect1.display();
cout << "rect2 = "; rect2.display();
cout << "rect3 = "; rect3.display();
rect1 = rect2 = rect3;
cout << "After rect1 = rect2 = rect3; \n";
cout << "rect1 = "; rect1.display();
cout << "rect2 = "; rect2.display();
cout << "rect3 = "; rect3.display();
}
}
/////////////////////////////////////////////////////////////////////
// Display member functio
/////////////////////////////////////////////////////////////////////
void CRectangle::display(void) const
{
cout << "Rectangle (" << length << ", " << width << ')' << endl;
}
/////////////////////////////////////////////////////////////////////
// getLength
// Returns the length of the function
/////////////////////////////////////////////////////////////////////
int CRectangle::getLength(void) const //p01
{
return length;
}
/////////////////////////////////////////////////////////////////////
// testGetLength
/////////////////////////////////////////////////////////////////////
void testGetLength(void)
{
cout << "-------------------\n";
cout << "testGetLength(void)\n";
cout << "-------------------\n";
for (int i=0; i<TEST_COUNT; i++)
{
CRectangle rect('r');
rect.display();
cout << "Length = " << rect.getLength() << endl;
}
}
/////////////////////////////////////////////////////////////////////
// perimeter function member
// Calculates and returns the perimeter of the rectangle
/////////////////////////////////////////////////////////////////////
int CRectangle::perimeter(void) const
{
return (2*(length+width));
}
/////////////////////////////////////////////////////////////////////
// Test function for perimeter
/////////////////////////////////////////////////////////////////////
void testPerimeter(void)
{
cout << "-------------------\n";
cout << "testPerimeter(void)\n";
cout << "-------------------\n";
for (int i=0; i<TEST_COUNT; i++)
{
CRectangle rect('r');
rect.display();
cout << "Perimeter = " << rect.perimeter() << endl;
}
}
/////////////////////////////////////////////////////////////////////
// main function
/////////////////////////////////////////////////////////////////////
void main(void)
{
srand(time(NULL));
testConstructorDefault();
testConstructorWithDims();
testConstructorRand();
testPerimeter();
testGetLength();
testBadSet();
testAssignmentDefault();
testIsSquare();
testDestructor();
}
/*
SAMPLE RUN:
----------------------------
testConstructorDefault(void)
----------------------------
Rectangle (1, 1)
Using for loop:
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Using pointer p, while loop, and p++:
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Using pointer p, for loop, and (p+i)-> :
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Using pointer p, for loop, and (*(p+i)). :
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Rectangle (1, 1)
Destructor called
Destructor called
Destructor called
Destructor called
Destructor called
Destructor called
-----------------------------
testConstructorWithDims(void)
-----------------------------
len = -1, wid = 7
CRectangle rect(len, wid); => Rectangle (1, 7)
Destructor called
len = 17, wid = 15
CRectangle rect(len, wid); => Rectangle (17, 15)
Destructor called
len = 10, wid = 12
CRectangle rect(len, wid); => Rectangle (10, 12)
Destructor called
len = 16, wid = 10
CRectangle rect(len, wid); => Rectangle (16, 10)
Destructor called
len = 2, wid = 15
CRectangle rect(len, wid); => Rectangle (2, 15)
Destructor called
-------------------------
testConstructorRand(void)
-------------------------
CRectangle rect1('s'); => Rectangle (19, 19)
Destructor called
CRectangle rect1('r'); => Rectangle (18, 17)
Destructor called
CRectangle rect1('r'); => Rectangle (14, 5)
Destructor called
CRectangle rect1('R'); => Rectangle (11, 18)
Destructor called
CRectangle rect1('S'); => Rectangle (19, 19)
Destructor called
-------------------
testPerimeter(void)
-------------------
Rectangle (12, 15)
Perimeter = 54
Destructor called
Rectangle (1, 3)
Perimeter = 8
Destructor called
Rectangle (2, 11)
Perimeter = 26
Destructor called
Rectangle (8, 15)
Perimeter = 46
Destructor called
Rectangle (13, 17)
Perimeter = 60
Destructor called
-------------------
testGetLength(void)
-------------------
Rectangle (9, 15)
Length = 9
Destructor called
Rectangle (2, 6)
Length = 2
Destructor called
Rectangle (3, 18)
Length = 3
Destructor called
Rectangle (18, 13)
Length = 18
Destructor called
Rectangle (14, 1)
Length = 14
Destructor called
----------------
testBadSet(void)
----------------
Rectangle (1, 9)
After r1.badSet()=99; Rectangle (99, 9)
Destructor called
Rectangle (2, 15)
After r1.badSet()=99; Rectangle (99, 15)
Destructor called
Rectangle (8, 10)
After r1.badSet()=99; Rectangle (99, 10)
Destructor called
Rectangle (13, 11)
After r1.badSet()=99; Rectangle (99, 11)
Destructor called
Rectangle (19, 17)
After r1.badSet()=99; Rectangle (99, 17)
Destructor called
---------------------------
testAssignmentDefault(void)
---------------------------
rect1 = Rectangle (1, 5)
rect2 = Rectangle (18, 10)
rect3 = Rectangle (18, 12)
After rect1 = rect2 = rect3;
rect1 = Rectangle (18, 12)
rect2 = Rectangle (18, 12)
rect3 = Rectangle (18, 12)
Destructor called
Destructor called
Destructor called
rect1 = Rectangle (1, 9)
rect2 = Rectangle (16, 12)
rect3 = Rectangle (19, 9)
After rect1 = rect2 = rect3;
rect1 = Rectangle (19, 9)
rect2 = Rectangle (19, 9)
rect3 = Rectangle (19, 9)
Destructor called
Destructor called
Destructor called
rect1 = Rectangle (7, 1)
rect2 = Rectangle (3, 6)
rect3 = Rectangle (17, 4)
After rect1 = rect2 = rect3;
rect1 = Rectangle (17, 4)
rect2 = Rectangle (17, 4)
rect3 = Rectangle (17, 4)
Destructor called
Destructor called
Destructor called
rect1 = Rectangle (2, 9)
rect2 = Rectangle (5, 15)
rect3 = Rectangle (14, 10)
After rect1 = rect2 = rect3;
rect1 = Rectangle (14, 10)
rect2 = Rectangle (14, 10)
rect3 = Rectangle (14, 10)
Destructor called
Destructor called
Destructor called
rect1 = Rectangle (17, 6)
rect2 = Rectangle (8, 13)
rect3 = Rectangle (3, 13)
After rect1 = rect2 = rect3;
rect1 = Rectangle (3, 13)
rect2 = Rectangle (3, 13)
rect3 = Rectangle (3, 13)
Destructor called
Destructor called
Destructor called
------------------
testIsSquare(void)
------------------
Rectangle (16, 5)
Is NOT square
Destructor called
Rectangle (15, 11)
Is NOT square
Destructor called
Rectangle (10, 3)
Is NOT square
Destructor called
Rectangle (6, 6)
Is square
Destructor called
Rectangle (8, 14)
Is NOT square
Destructor called
--------------------
testDestructor(void)
--------------------
Rectangle (1, 1)
Destructor called
Rectangle (1, 1)
Destructor called
Dynamic array of rectangles
Rectangle (1, 1)
Destructor called
Destructor called
Destructor called
Destructor called
Destructor called
Static rectangle
Rectangle (1, 1)
out of scope of static
Static rectangle
Rectangle (1, 1)
Destructor called
Destructor called
Press any key to continue
*/
|