rect03
[ Home ] [ Up ]

//File:    rect03.cpp
//Date:    02/08/2002
//Authors: Us


////////////////////////////////////////////////////////////
//Problem: define rectangle type and some operations for it
////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////
// includes
////////////////////////////////////////////////////////////
#include <iostream.h>
#include <stdlib.h>
#include <time.h>


////////////////////////////////////////////////////////////
// type TRectangle definition
////////////////////////////////////////////////////////////
const int TEST_COUNT = 5;


////////////////////////////////////////////////////////////
// type TRectangle definition
////////////////////////////////////////////////////////////
struct TRectangle
  {
  int length;
  int width;
  };


////////////////////////////////////////////////////////////
// prototype
////////////////////////////////////////////////////////////
void init(TRectangle &rec, const int a, const int b);
void init(TRectangle &rec, const char ch);
void display(const TRectangle &rec);
bool areEqual(const TRectangle &rec1, const TRectangle &rec2);
bool operator == (const TRectangle &rec1, const TRectangle &rec2);
bool operator != (const TRectangle &rec1, const TRectangle &rec2);
ostream & operator << (ostream &bob, const TRectangle &rec);


////////////////////////////////////////////////////////////
// prototype test functions
////////////////////////////////////////////////////////////
void testInit1(void);
void testInit2(void);
void testOperatorEqual(void);
void testOperatorNotEqual(void);


////////////////////////////////////////////////////////////
// main
////////////////////////////////////////////////////////////
void main(void)
  {
  srand(time(NULL));

  testInit1();
  testInit2();
  testOperatorEqual();
  testOperatorNotEqual();
  }


////////////////////////////////////////////////////////////
// init
////////////////////////////////////////////////////////////
void init(TRectangle &rec, const int a, const int b)
  {
  if (a < 0) 
      rec.length = -a;
    else
      rec.length = a;

  if (b < 0) 
      rec.width = -b;
    else
      rec.width = b;

  if (0 == a) 
      rec.length = 1;

  if (0 == b) 
      rec.width = 1;
  }


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
// testInit1
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void testInit1(void)
  {
  cout << "init(TRectangle &rec, const int a, const int b)\n";
  cout << "===============================================\n";

  for (int i=1; i<=TEST_COUNT; i++)
    {
    TRectangle r1;

    int a = -10 + rand()%21;
    int b = -10 + rand()%21;

    cout << "a= " << a << ", b= " << b << endl;

    cout << "Before init(r1, a, b);\n";
    cout <<r1;
    init(r1, a, b);
    cout << "After init(r1, a, b);\n";
    cout << r1;

    TRectangle *p1;
    p1 = new TRectangle;

    cout << "Before init(*p1, a, b);\n";
    cout << *p1;
    init(*p1, a, b);
    cout << "Before init(*p1, a, b);\n";
    cout << *p1;
    delete p1;

    cout << "-----------------------\n";
    }
  }


////////////////////////////////////////////////////////////
// init
////////////////////////////////////////////////////////////
void init(TRectangle &rec, const char ch)
  {
  if (('r' == ch) || ('R' == ch))
    {
    rec.length = 1 + rand()%10;
    rec.width  = 1 + rand()%10;
    }
  else
    {
    rec.length = 1;
    rec.width  = 1;
    }
  }


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
// testInit2
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void testInit2(void)
  {
  cout << "init(TRectangle &rec, const char ch)\n";
  cout << "====================================\n";

  for (int i=1; i<=TEST_COUNT; i++)
    {
    TRectangle r1;
    char ch;
    char characters[] = {'r', 'R', 'x'};

    int a = rand()%3;

    ch = characters[a];

    cout << "ch= " << ch << endl;

    cout << "Before init(r1, ch);\n";
    cout <<r1;
    init(r1, ch);
    cout << "After init(r1, ch);\n";
    cout << r1;

    TRectangle *p1;
    p1 = new TRectangle;

    cout << "Before init(*p1, ch);\n";
    cout << *p1;
    init(*p1, ch);
    cout << "After init(*p1, ch);\n";
    cout << *p1;
    delete p1;

    cout << "-----------------------\n";
    }
  }


////////////////////////////////////////////////////////////
// display
////////////////////////////////////////////////////////////
void display(const TRectangle &rec)
  {
  cout << "rect(" << rec.length << ", " 
       << rec.width << ')' << endl;
  }


////////////////////////////////////////////////////////////
// areEqual
////////////////////////////////////////////////////////////
bool areEqual(const TRectangle &rec1, const TRectangle &rec2)
  {
  return (rec1.length == rec2.length) 
      && (rec1.width == rec2.width);
  }


////////////////////////////////////////////////////////////
// operator ==
////////////////////////////////////////////////////////////
bool operator == (const TRectangle &rec1, const TRectangle &rec2)
  {
  return (rec1.length == rec2.length) 
      && (rec1.width == rec2.width);
  }


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
// testOperatorEqual
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void testOperatorEqual(void)
  {
  cout << "bool operator == (rec1, rec2)\n";
  cout << "=============================\n";

  for (int i=1; i<=TEST_COUNT; i++)
    {
    TRectangle r1, r2;
    init(r1, 'r');
    init(r2, 'r');

    cout << "Initially\n";
    
    cout << "r1=" << r1;
    cout << "r2=" << r2;

    if (r1 == r2)
        cout << "Are Equal\n";
      else
        cout << "Not Equal\n";

    r1 = r2;
    cout << "After r1 = r2;\n";

    cout << "r1=" << r1;
    cout << "r2=" << r2;

    if (r1 == r2)
        cout << "Are Equal\n";
      else
        cout << "Not Equal\n";

    cout << "-----------------------\n";
    }
  }


////////////////////////////////////////////////////////////
// operator !=
////////////////////////////////////////////////////////////
bool operator != (const TRectangle &rec1, const TRectangle &rec2)
  {
  return !(rec1 == rec2); 
  }


/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
// testOperatorNotEqual
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void testOperatorNotEqual(void)
  {
  cout << "bool operator != (rec1, rec2)\n";
  cout << "=============================\n";

  for (int i=1; i<=TEST_COUNT; i++)
    {
    TRectangle r1, r2;
    init(r1, 'r');
    init(r2, 'r');

    cout << "Initially\n";
    
    cout << "r1=" << r1;
    cout << "r2=" << r2;

    if (r1 != r2)
        cout << "Not Equal\n";
      else
        cout << "Are Equal\n";

    r1 = r2;
    cout << "After r1 = r2;\n";

    cout << "r1=" << r1;
    cout << "r2=" << r2;

    if (r1 != r2)
        cout << "Not Equal\n";
      else
        cout << "Are Equal\n";

    cout << "-----------------------\n";
    }
  }


////////////////////////////////////////////////////////////
// operator << for output
////////////////////////////////////////////////////////////
ostream & operator << (ostream &bob, const TRectangle &rec)
  {
  bob << "rect(" << rec.length << ", " 
       << rec.width << ')' << endl;

  return bob;
  }


/**********************************************************/
// SAMPLE OUTPUT
/**********************************************************/
/*
init(TRectangle &rec, const int a, const int b)
===============================================
a= -2, b= 8
Before init(r1, a, b);
rect(-858993460, -858993460)
After init(r1, a, b);
rect(2, 8)
Before init(*p1, a, b);
rect(-842150451, -842150451)
Before init(*p1, a, b);
rect(2, 8)
-----------------------
a= 8, b= -5
Before init(r1, a, b);
rect(2, 8)
After init(r1, a, b);
rect(8, 5)
Before init(*p1, a, b);
rect(-842150451, -842150451)
Before init(*p1, a, b);
rect(8, 5)
-----------------------
a= 7, b= 8
Before init(r1, a, b);
rect(8, 5)
After init(r1, a, b);
rect(7, 8)
Before init(*p1, a, b);
rect(-842150451, -842150451)
Before init(*p1, a, b);
rect(7, 8)
-----------------------
a= -9, b= 8
Before init(r1, a, b);
rect(7, 8)
After init(r1, a, b);
rect(9, 8)
Before init(*p1, a, b);
rect(-842150451, -842150451)
Before init(*p1, a, b);
rect(9, 8)
-----------------------
a= 4, b= -1
Before init(r1, a, b);
rect(9, 8)
After init(r1, a, b);
rect(4, 1)
Before init(*p1, a, b);
rect(-842150451, -842150451)
Before init(*p1, a, b);
rect(4, 1)
-----------------------
init(TRectangle &rec, const char ch)
====================================
ch= R
Before init(r1, ch);
rect(-858993460, -858993460)
After init(r1, ch);
rect(1, 4)
Before init(*p1, ch);
rect(-842150451, -842150451)
After init(*p1, ch);
rect(10, 5)
-----------------------
ch= x
Before init(r1, ch);
rect(1, 4)
After init(r1, ch);
rect(1, 1)
Before init(*p1, ch);
rect(-842150451, -842150451)
After init(*p1, ch);
rect(1, 1)
-----------------------
ch= r
Before init(r1, ch);
rect(1, 1)
After init(r1, ch);
rect(5, 5)
Before init(*p1, ch);
rect(-842150451, -842150451)
After init(*p1, ch);
rect(9, 1)
-----------------------
ch= x
Before init(r1, ch);
rect(5, 5)
After init(r1, ch);
rect(1, 1)
Before init(*p1, ch);
rect(-842150451, -842150451)
After init(*p1, ch);
rect(1, 1)
-----------------------
ch= x
Before init(r1, ch);
rect(1, 1)
After init(r1, ch);
rect(1, 1)
Before init(*p1, ch);
rect(-842150451, -842150451)
After init(*p1, ch);
rect(1, 1)
-----------------------
bool operator == (rec1, rec2)
=============================
Initially
r1=rect(6, 3)
r2=rect(9, 1)
Not Equal
After r1 = r2;
r1=rect(9, 1)
r2=rect(9, 1)
Are Equal
-----------------------
Initially
r1=rect(10, 2)
r2=rect(4, 9)
Not Equal
After r1 = r2;
r1=rect(4, 9)
r2=rect(4, 9)
Are Equal
-----------------------
Initially
r1=rect(8, 9)
r2=rect(10, 6)
Not Equal
After r1 = r2;
r1=rect(10, 6)
r2=rect(10, 6)
Are Equal
-----------------------
Initially
r1=rect(5, 4)
r2=rect(9, 8)
Not Equal
After r1 = r2;
r1=rect(9, 8)
r2=rect(9, 8)
Are Equal
-----------------------
Initially
r1=rect(4, 8)
r2=rect(10, 5)
Not Equal
After r1 = r2;
r1=rect(10, 5)
r2=rect(10, 5)
Are Equal
-----------------------
bool operator != (rec1, rec2)
=============================
Initially
r1=rect(8, 9)
r2=rect(7, 6)
Not Equal
After r1 = r2;
r1=rect(7, 6)
r2=rect(7, 6)
Are Equal
-----------------------
Initially
r1=rect(7, 6)
r2=rect(3, 10)
Not Equal
After r1 = r2;
r1=rect(3, 10)
r2=rect(3, 10)
Are Equal
-----------------------
Initially
r1=rect(8, 2)
r2=rect(6, 4)
Not Equal
After r1 = r2;
r1=rect(6, 4)
r2=rect(6, 4)
Are Equal
-----------------------
Initially
r1=rect(6, 5)
r2=rect(6, 7)
Not Equal
After r1 = r2;
r1=rect(6, 7)
r2=rect(6, 7)
Are Equal
-----------------------
Initially
r1=rect(6, 8)
r2=rect(2, 4)
Not Equal
After r1 = r2;
r1=rect(2, 4)
r2=rect(2, 4)
Are Equal
-----------------------
Press any key to continue
*/