Selected C Example 17

Selected C++ Example #17

 //Example #17  // This example code shows the attempt to implement three // different lists (meal lists, airplane lists, and dog lists) // with one implementation of the list code. The general approach // is to use inheritance to weaken the type-checking mechanism // of C++ by making all data types that want to be in a list // inherit from a common base class (in this case the class // ListItem). The common base class captures any necessary // operations that the LinkedList class might need (in this // case, print() and type()). The problem with weak type // checking is that a wrong derived object might end up on // the wrong list. The benefits of mixed list and strong // type checking are captured in the next example, which // reimplements this code with C++ templates. // This example could be extended to include type checking. // The algorithm for doing this is to have each LinkedList // object remember the data type of the first argument inserted. // Once this is recorded all other insertions will check the // type of the object being added to the list with the stored // value. Of course, this algorithm makes it impossible to // have mixed data type lists anywhere in the application. #include <iostream.h> #include <new.h> // ListItem is the class responsible for weakening the type // checking of C++. We make all of our list element classes // inherit from this common base class. The LinkedList will // be of pointers to this base class. Note that all ListItems // must know how to give their type and print themselves. class ListItem { public:      virtual void print(ostream& o = cout) = 0;      virtual const char* type() = 0; }; // The derived classes Dog, Meal, and Airplane are only // skeleton classes to simplify their implementation. class Dog : public ListItem { public:      void bark();      void bite();      void print(ostream&o = cout);      const char* type(); }; void Dog::bark() {      cout << ''Bow Wow\n''; } void Dog::bite() {      cout << ''Ouch!!!\n''; } void Dog::print(ostream& o) {      o << ''I am a dog!\n''; } const char* Dog::type() {       return(''Dog''); } class Meal : public ListItem { public:      void eat();      void print(ostream& o = cout);      const char* type(); }; void Meal::eat() {      cout << ''Crunch ... Munch ... Crunch ... \n''; } void Meal::print(ostream& o) {      o << ''I'm a meal\n''; } const char* Meal::type() {      return(''Meal''); } class Airplane : public ListItem { public:       void fly();       void print(ostream& o = cout);       const char* type(); }; void Airplane::fly() {      cout << ''Va-a-a--room!!!\n''; } void Airplane::print(ostream& o) {      o << ''I'm an airplane!\n''; } const char* Airplane::type() {      return(''Airplane''); } typedef ListItem* DATUM; class LinkedList {      struct Node {          DATUM data;          Node* next;      public:          Node(DATUM&);      };      Node* head;      int len; public:      LinkedList();      ~LinkedList();      int insert(DATUM&);      DATUM remove();      void traverse()const;      int length(); }; LinkedList::Node::Node(DATUM& new_data) {      data = new_data;      next = NULL; } LinkedList::LinkedList() {      head = NULL;      len = 0; } LinkedList::~LinkedList() {      Node* temp;      while (head != NULL) {          temp = head;          head = head->next;          delete temp;      } } int LinkedList::insert(DATUM& new_item) {      Node* temp = head;      if (temp == NULL) {           head = new Node(new_item);      }      else {           while (temp->next != NULL) {                      temp = temp->next;           }           temp->next = new Node(new_item);      }      return(++len); } // The remove method needs something to return if the list // is empty. We deal with this problem by creating a dummy // DATUM as an internal variable within the remove method. DATUM LinkedList::remove() {      Node* temp = head;      static DATUM bad_item;      DATUM retval;      if (temp == NULL) {           return(bad_item);      }      else {           retval = head->data;           head = head->next;           len--;           delete temp;           return(retval);      } } // Notice that the traverse method sends a message to the // data in each node to print itself. This sets up a requirement // that any data type that wants to be in a LinkedList needs // a print method (this constraint is enforced in the base // class ''ListItem''). An even more important consideration is // the fact that the syntax is different if DATUM is a pointer // or nonpointer. Nonpointers would use a dot, and not // an arrow, operator. This problem carries over to templates // as well. It is common to see templates advertise which types // they can, and cannot, handle. void LinkedList::traverse() const {      Node* temp = head;      cout << ''(\n'';      while (temp != NULL) {          temp->data->print();          cout << ''\n'';          temp = temp->next;      }      cout << '')\n\n''; } int LinkedList::length() {      return(len); } void main() {      LinkedList MealList, AirplaneList, DogList;      Meal *meal1 = new Meal, *meal2 = new Meal, *meal3 = new Meal;      Dog *dog1 = new Dog, *dog2 = new Dog, *dog3 = new Dog;      Airplane *air1 = new Airplane, *air2 = new Airplane, *air3 = new Airplane; // At first glance everything seems to work nicely.       MealList.insert(meal1);       MealList.insert(meal2);       MealList.insert(meal3);       Meal* aMeal = (Meal*) MealList.remove();       aMeal->eat();       AirplaneList.insert(air1);       AirplaneList.insert(air2);       AirplaneList.insert(air3);       DogList.insert(dog1);       DogList.insert(dog2);       DogList.insert(dog3);       MealList.traverse();       AirplaneList.traverse();       DogList.traverse(); // Until we see some of the nasty side effects of weak type // checking. This code accidentally flies a dog off the // runway at the airport.       AirplaneList.insert(dog2);       DATUM anItem;       while (AirplaneList.length() != 0){           anItem = AirplaneList.remove();           cout << ''My real type is '' << anltem->type() << ''\n'';           cout << ''I can fly. . .watch. . . \n'';           ((Airplane*) anItem)->fly();       }       delete meal1;       delete meal2;       delete meal3;       delete dogl;       delete dog2;       delete dog3;       delete air1;       delete air2;       delete air3; }