p04Books01
[ Home ] [ Up ]

//p04books01
//author
//date 07/19/2001
//////////////////////////////////////////////////////////////////////
//include files
//////////////////////////////////////////////////////////////////////
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>


//////////////////////////////////////////////////////////////////////
//constants
//////////////////////////////////////////////////////////////////////
const int TITLE_LEN = 30;
const int AUTHOR_LEN = 30;
const int MAX_BOOKS = 15;


//////////////////////////////////////////////////////////////////////
//test values
//////////////////////////////////////////////////////////////////////
const char *testTitles[] = 
  {
  "C++ with Pizza Flavor", "Java Learn Now", "COBOL How To Forget",
  "FORTRAN 77", "DB2: An Introduction", "XML In 24 Hours",
  "UNIX"
  };

const int MAX_TITLES = sizeof(testTitles)/sizeof(testTitles[0]);

const char *testAuthors[] = 
  {
  "John", "Adam", "Sumeer", "Natalie", "David", "Rustin"
  };

const int MAX_AUTHORS = sizeof(testAuthors)/sizeof(testAuthors[0]);

const int testYears[] = {1977, 1988, 1989, 1991, 2000, 2001};

const int MAX_YEARS = sizeof(testYears)/sizeof(testYears[0]);


void testSortByYear(void);
void testAdd(void);


//////////////////////////////////////////////////////////////////////
//BookType class definition
//////////////////////////////////////////////////////////////////////
class CBook
  {
  private:
    char title[TITLE_LEN+1];
    char author[AUTHOR_LEN+1];
    int year;
    CBook *next;
  public:
    CBook(void);
    CBook(char t[], char a[], int y);
    CBook(char ch);
    CBook(const CBook &b); //CBook b2; CBook b1(b2);
    void display(void) const;
    void copy(const CBook &b2);
    void swap(CBook &b2);
    friend class CBooks;

    ~CBook(void);
    bool operator == (const CBook &b2) const;
    bool operator != (const CBook &b2) const;
    CBook  & operator = (const CBook &b2);

    friend ostream & operator  << (ostream & john, const CBook &b); 
    friend void swapYear(CBook &b1, CBook &b2);

    friend ostream & operator  << (ostream & john, const CBooks &bc); 

  };


//////////////////////////////////////////////////////////////////////
//class CBooks
//////////////////////////////////////////////////////////////////////
class CBooks
  {
  private:
    int count;
    CBook *head;
    CBook *tail;
  public:
    CBooks(void);
    CBooks(int n);
    CBooks(const CBooks &bc);
    void display(void) const;
    void displayRev(void) const;
    void sortBubbleByYear(void);
    bool isSortedByYear(void) const;
    int add(char t[], char a[], int y);
    int remove(int loc); // Project #4
    ~CBooks(void);
    bool isEqualTo(const CBooks &bc2) const;
    bool operator ==(const CBooks &bc2) const;
    bool operator !=(const CBooks &bc2) const;

    friend ostream & operator  << (ostream & john, const CBooks &bc); 
    CBooks(char ch);
    void sortSelectionByYear(void);
    void sortBubbleByTitle(void);
    bool isSortedByTitle(void) const;

    void sortInsertionByYear(void);

    void removeAll(void);
    int add(const CBook &b);
  };


void testOperatorInsertionCBooks(void);
void testAdd(void);

void main(void)
  {
  testOperatorInsertionCBooks();
  testAdd();

  }


/*
void CBooks::sortInsertionByYear(void)
  {
  int i, k;
  CBook temp;

  for (i=1; i<=count-1; i++)
    {
    if (books[i-1].year <= books[i].year)
        continue;
    temp = books[i];
    k = i;
    while (true)
      {
      books[k] = books[k-1];
      k--;

      if ((0 == k) || (books[k-1].year <= temp.year))
          {
          books[k] = temp;
          break;
          }
      }
    }
  }


//////////////////////////////////////////////////////////////////////
//test function for sortSelectionByYear
//////////////////////////////////////////////////////////////////////
void testSortInsertionByYear(void)
  {
  int n = rand()% (MAX_BOOKS + 1);

  CBooks bc(n);
  cout << "Original\n";
  bc.display();

  if (bc.isSortedByYear())
      cout << "SORTED\n";
    else
      cout << "NOT SORTED\n";

  bc.sortInsertionByYear();
  cout << "After sort\n";
  bc.display();

  if (bc.isSortedByYear())
      cout << "SORTED\n";
    else
      cout << "NOT SORTED\n";

  }


*/
  
/*
//////////////////////////////////////////////////////////////////////
//sortBubbleByTitle()
//////////////////////////////////////////////////////////////////////
void CBooks::sortBubbleByTitle(void)
  {
  bool sorted;
  int i;
  
  do 
    {
    sorted = true;
    for (i=0; i<=count-2; i++)
      {
      if (strcmp(books[i].title, books[i+1].title) > 0) 
        {
        books[i].swap(books[i+1]);
        sorted = false;
        }
      }
    }
    while (!sorted); 
  }


//////////////////////////////////////////////////////////////////////
//test function for sortByTitle
//////////////////////////////////////////////////////////////////////
void testSortByTitle(void)
  {
  int n = rand()% (MAX_BOOKS + 1);

  CBooks bc(n);
  cout << "Original\n";
  bc.display();

  if (bc.isSortedByTitle())
      cout << "SORTED\n";
    else
      cout << "NOT SORTED\n";

  bc.sortBubbleByTitle();
  cout << "Sorted\n";
  bc.display();

  if (bc.isSortedByYear())
      cout << "SORTED\n";
    else
      cout << "NOT SORTED\n";

  }


//////////////////////////////////////////////////////////////////////
//checks if sorted by title
//////////////////////////////////////////////////////////////////////
bool CBooks::isSortedByTitle(void) const
  {
  if (count <= 1)
      return true;

  for (int i=0; i<=count-2; i++)
    {
    if (strcmp(books[i].title, books[i+1].title) > 0)
        return false;
    }
  
  return true;
  }


*/


/*
void CBooks::sortSelectionByYear(void)
  {
  int n = count;
  int iMax, vMax, i;
  while (n > 1)
    {
    iMax = 0;
    vMax = books[iMax].year;
    for (i=1; i<=n-1; i++)
      {
      if (books[i].year > vMax)
          {
          iMax = i;
          vMax = books[i].year;
          }
      }

    books[iMax].swap(books[n-1]);
    n--;
    }
  }


//////////////////////////////////////////////////////////////////////
//test function for sortSelectionByYear
//////////////////////////////////////////////////////////////////////
void testSortSelectionByYear(void)
  {
  int n = rand()% (MAX_BOOKS + 1);

  CBooks bc(n);
  cout << "Original\n";
  bc.display();

  if (bc.isSortedByYear())
      cout << "SORTED\n";
    else
      cout << "NOT SORTED\n";

  bc.sortSelectionByYear();
  cout << "Sorted\n";
  bc.display();

  if (bc.isSortedByYear())
      cout << "SORTED\n";
    else
      cout << "NOT SORTED\n";

  }

*/

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
CBooks::CBooks(char ch)
  {
  if (('r' == ch) || ('R' == ch))
      {
      count = rand()%(MAX_BOOKS+1);

      for (int i=0; i<count; i++)
        this->add(CBook('r'));
      }
    else
      count = 0;
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
void testConstructorRandCBooks(void)
  {
  CBooks bc1('r'), bc2('s');
  cout << bc1 << endl;
  cout << endl;
  cout << bc2 << endl;

  }




//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
ostream & operator  << (ostream & john, const CBooks &bc)
  {
  john << "Book Collection[" << bc.count << "]= \n";
  /*
  CBook *p;
  p = bc.head;
  while (p != NULL)
    {
    john << *p;
    p = p->next;
    }

  john << endl;
  */

  for (CBook *p = bc.head; p != NULL; p = p->next)
    john << *p;

  return john;
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
void testOperatorInsertionCBooks(void)
  {
  //CBooks bc1(5), bc2(5);

  CBooks bc1, bc2;

  cout << bc1 << bc2 << endl;
  }




/*
//////////////////////////////////////////////////////////////////////
//compares for equality CBooks objects
//////////////////////////////////////////////////////////////////////
bool CBooks::operator ==(const CBooks &bc2) const
  {
  if (count != bc2.count)
      return false;


  // if != overloaded for CBook
  for (int i=0; i<=count-1; i++)
    if (this->books[i] != bc2.books[i])
      return false;

  return true;
  }


//////////////////////////////////////////////////////////////////////
//test operator equal
//////////////////////////////////////////////////////////////////////
void testOperatorEqual(void)
  {
  CBooks bc1(5), bc2(5);
  if (bc1 == bc2)
      cout << "EQUAL\n";
    else
      cout << "NOT Equal\n";

  CBooks bc3(bc1);
  if (bc1 == bc3)
      cout << "EQUAL\n";
    else
      cout << "NOT Equal\n";
  }



*/
/*
//////////////////////////////////////////////////////////////////////
//compares for inequality CBooks objects
//////////////////////////////////////////////////////////////////////
bool CBooks::operator !=(const CBooks &bc2) const
  {
  return !((*this) == bc2);
  }


//////////////////////////////////////////////////////////////////////
//test operator not equal to
//////////////////////////////////////////////////////////////////////
void testOperatorNotEqual(void)
  {
    {
    CBooks bc1(5), bc2(5);
    if (bc1 != bc2)
        cout << "Not EQUAL\n";
      else
        cout << "Equal\n";

    CBooks bc3(bc1);
    if (bc1 != bc3)
        cout << "NOT EQUAL\n";
      else
        cout << "Equal\n";
    }

    {
    CBooks bc1, bc2;
    if (bc1 != bc2)
        cout << "Not EQUAL\n";
      else
        cout << "Equal\n";

    CBooks bc3(bc1);
    if (bc1 != bc3)
        cout << "NOT EQUAL\n";
      else
        cout << "Equal\n";
    }

  }


*/

void CBooks::removeAll(void)
  {
  }

//////////////////////////////////////////////////////////////////////
//Cooks destructor 
//////////////////////////////////////////////////////////////////////
CBooks::~CBooks(void)
  {
  removeAll();
  }



//////////////////////////////////////////////////////////////////////
//add function
//////////////////////////////////////////////////////////////////////
int CBooks::add(const CBook &b)
  {
  CBook *p;
  p = new CBook;

  if (NULL == p) 
      return -1;

  strcpy(p->title, b.title);
  strcpy(p->author, b.author);
  p->year = b.year;
  p->next = NULL;

  if (NULL == head)
      head = tail = p;
    else
      {
      tail->next = p;
      tail = p;
      }

  count++;
  return count-1;
  }


//////////////////////////////////////////////////////////////////////
//add function
//////////////////////////////////////////////////////////////////////
int CBooks::add(char t[], char a[], int y)
  {
  CBook *p;
  p = new CBook;

  if (NULL == p) 
      return -1;

  strcpy(p->title, t);
  strcpy(p->author, a);
  p->year = y;
  p->next = NULL;

  if (NULL == head)
      head = tail = p;
    else
      {
      tail->next = p;
      tail = p;
      }

  count++;
  return count-1;
  }


//////////////////////////////////////////////////////////////////////
//test add
//////////////////////////////////////////////////////////////////////
void testAdd(void)
  {
  CBooks bc;
  cout << bc;
  for (int i=1; i<=5; i++)
    {
    cout << "+++++++++++++++++++++++++++\n";
    cout << bc.add("Title", "Author", i) << endl;
    cout << bc;
    }

  CBooks bc2;
  cout << bc2;
  for (int j=1; j<=5; j++)
    {
    cout << "+++++++++++++++++++++++++++\n";
    cout << bc2.add(CBook('r')) << endl;
    cout << bc2;
    }

  }


//////////////////////////////////////////////////////////////////////
//constructor CBooks()
//////////////////////////////////////////////////////////////////////
CBooks::CBooks(void)
  {
  count = 0;
  head = tail = NULL;
  }


/*
//////////////////////////////////////////////////////////////////////
//constructor CBooks(n)
//////////////////////////////////////////////////////////////////////
CBooks::CBooks(int n)
  {
  if (n < 0) 
    n = 0;
  
  if (n > MAX_BOOKS)
    n = MAX_BOOKS;

  count = n;
  for (int i=0; i<n; i++)
    {
    //get a random title
    strcpy(books[i].title, testTitles[rand()%MAX_TITLES]);
    //get a random author
    strcpy(books[i].author, testAuthors[rand()%MAX_AUTHORS]);
    //get a random year
    books[i].year = testYears[rand()%MAX_YEARS];
    }
  }


//////////////////////////////////////////////////////////////////////
//constructor CBooks(CBooks bc)
//////////////////////////////////////////////////////////////////////
CBooks::CBooks(const CBooks &bc)
  {
  count = bc.count;
  for (int i=0; i<count; i++)
    {
    //get a random title
    strcpy(books[i].title, bc.books[i].title);
    //get a random author
    strcpy(books[i].author, bc.books[i].author);
    //get a random year
    books[i].year = bc.books[i].year;
    }
  }

*/

//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
ostream & operator  << (ostream & john, const CBook &b)
  {
  john << b.title ;
  john << ", " << b.author;
  john << ", " << b.year << endl;

  return john;
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
void testOperatorInsertionCBook(void)
  {
  CBook b1('r'), b2('r');

  cout << b1 << b2 << endl;
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
CBook & CBook::operator = (const CBook &b2)
  {
  strcpy(title, b2.title);
  strcpy(author, b2.author);
  year = b2.year;
  return *this;
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
void testOperatorAssignCBook(void)
  {
  CBook b1('r'), b2('r'), b3('R');
  cout << b1;
  cout << b2;
  cout << b3;

  b1 = b2 = b3;
  cout << b1;
  cout << b2;
  cout << b3;
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
bool CBook::operator != (const CBook &b2) const
  {
  return !(*this == b2);
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
void testOperatorNotEqualCBook(void)
  {
  CBook b1('r'), b2('r');
  cout << b1;
  cout << b2;
  if (b1 != b2)
      cout << "NOT EQUAL\n";
    else
      cout << "EQUAL\n";

  b2 = b1;
  cout << b1;
  cout << b2;
  if (b1 != b2)
      cout << "NOT EQUAL\n";
    else
      cout << "EQUAL\n";

  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
bool CBook::operator == (const CBook &b2) const
  {
  if (strcmp(this->title, b2.title) != 0)
      return false;

  if (strcmp(this->author, b2.author) != 0)
      return false;

  if (this->year != b2.year)
      return false;

  return true;
  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
void testOperatorEqualCBook(void)
  {
  CBook b1('r'), b2('r');
  cout << b1;
  cout << b2;
  if (b1 == b2)
      cout << "EQUAL\n";
    else
      cout << "NOT EQUAL\n";

  b2 = b1;
  cout << b1;
  cout << b2;
  if (b1 == b2)
      cout << "EQUAL\n";
    else
      cout << "NOT EQUAL\n";

  }


//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
CBook::~CBook(void)
  {
  }


//////////////////////////////////////////////////////////////////////
//function to initialize the contents of CBook variable
//////////////////////////////////////////////////////////////////////
CBook::CBook(char t[], char a[], int y)
  {
  strcpy((*this).title, t);//strcpy(title, t);
  strcpy(this->author, a); //strcpy(author, a);
  year = y;
  }


//////////////////////////////////////////////////////////////////////
//function to initialize the contents of CBook variable
//////////////////////////////////////////////////////////////////////
CBook::CBook(void)
  {
  strcpy((*this).title, "-1");
  strcpy(this->author, "-1");
  year = -1;
  }


//////////////////////////////////////////////////////////////////////
//function to initialize the contents of CBook variable
//////////////////////////////////////////////////////////////////////
CBook::CBook(const CBook &b)
  {
  strcpy(title, b.title);
  strcpy(author, b.author);
  year = b.year;
  }


//////////////////////////////////////////////////////////////////////
//function to input the contents of BookType variable
//////////////////////////////////////////////////////////////////////
CBook::CBook(char ch)
  {
  if (('i' == ch) || ('I' == ch))
      {
      cout << "Title:  "; cin >> title;
      cout << "Author: "; cin >> author;
      cout << "Year:   "; cin >> year;
      }
    else if (('r' == ch) || ('R' == ch))
      {
      strcpy(title, testTitles[rand()%MAX_TITLES]);
      strcpy(author, testAuthors[rand()%MAX_AUTHORS]);
      year = testYears[rand()%MAX_YEARS];
      }
    else
      {
      strcpy((*this).title, "-1");
      strcpy(this->author, "-1");
      year = -1;
      }

  }