Selected C Example 18

Selected C++ Example #18

 // Example #18  // 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 C++ templates to capture the common structure // that all LinkedLists share. The template is then used to // generate the three different lists. The advantage of templates // over weakened type checking via inheritance (Example #17) is // that mistakes of flying dogs off runways cannot occur (due to // the maintenance of strong type checking by templates). The // disadvantage is that we pay for the class/method code for each // new data type that wishes to have a list instantiation. #include <iostream.h> #include <new.h> // The derived classes Dog, Meal, and Airplane are only // skeleton classes, to simplify their implementation. class Dog { public:      void bark();      void bite();      void print(ostream& o = cout); }; void Dog::bark() {      cout << ''Bow Wow\n''; } void Dog::bite() {      cout << ''Ouch!!!\n''; } void Dog::print(ostream& o) {      o << ''I am a dog!\n''; } classMeal { public:      void eat();      void print(ostream& o = cout); }; void Meal::eat() {   cout << ''Crunch ... Munch ... Crunch ...\n''; } void Meal::print(ostream& o) {      o << ''I'm a meal\n''; } class Airplane { public:      void fly();      void print(ostream&o = cout); }; void Airplane::fly() {      cout << ''Va-a-a--room!!!\n''; } void Airplane::print(ostream& o) {      o << ''I'm an airplane!\n''; } // Borland wouldn' t accept nested templates, so the Node class is // placed outside the scope of the LinkedList. template <class DATUM> struct Node {      DATUM data;      Node* next; public:      Node(DATUM&); }; template <class DATUM> class LinkedList{       Node<DATUM>* head;       int len; public:      LinkedList();      ~LinkedList();      int insert(DATUM&);      DATUM remove();      void traverse() const;      int length(); }; template <class DATUM> Node<DATUM>::Node(DATUM& new_item) {      data = new_item;      next = NULL; } template <class DATUM> LinkedList<DATUM>::LinkedList() {      head = NULL;      len = 0; } template <class DATUM> LinkedList<DATUM>::~LinkedList() {      Node<DATUM>* temp;      while (head != NULL) {          temp = head;          head = head->next;          delete temp;      } } template <class DATUM> int LinkedList<DATUM>::insert(DATUM& new_item) {      Node<DATUM>* temp = head;      if (temp == NULL) {           head = new Node<DATUM>(new_item);     }      else {           while (temp->next != NULL) {                      temp = temp->next;           }           temp->next = new Node<DATUM>(new_item);      }      return(++len); } template <class DATUM> DATUM LinkedList<DATUM>::remove() {      Node<DATUM>* 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. 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. The template requires its DATUM to be // a pointer (in this example), and that the DATUM possess a // print method. template <class DATUM> void LinkedList<DATUM>::traverse() const {      Node<DATUM>* temp = head;      cout << ''(\n'';      while (temp != NULL) {          temp->data->print();          cout << ''\n'';          temp = temp->next;      }      cout << '')\n\n''; } template <class DATUM> int LinkedList<DATUM>::length() {      return(len); } void main() {      LinkedList<Meal*> MealList;      LinkedList<Airplane*> AirplaneList;      LinkedList<Dog*> DogList; // The following template expansion would generate errors due to // the traverse method requiring a pointer data type (or at least // a data type that supports the ''->'' operator). // //     LinkedList<Dog> x; //              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(meall);       MealList.insert(meal2);       MealList.insert(meal3);       Meal* aMeal = (Meal*) MealList. remove();       aMeal->eat();       char c;       cin >> c;       AirplaneList.insert(air1);       AirplaneList.insert(air2);       AirplaneList.insert(air3);       DogList.insert(dog1);       DogList.insert(dog2);       DogList.insert(dog3);       MealList.traverse();       AirplaneList.traverse();       DogList.traverse();       cin >> c; // The following line of code would generate compiler errors due to // the preservation of strong type checking by the C++ template // mechanism. // //         AirplaneList.insert(dog2);       delete meal1;       delete meal2;       delete meal3;       delete dog1;       delete dog2;       delete dog3;       delete air1;       delete air2;       delete air3; }