{"id":34,"date":"2024-08-01T18:35:48","date_gmt":"2024-08-01T18:35:48","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalC%2B%2BProgramming\/?page_id=34"},"modified":"2025-01-20T20:48:11","modified_gmt":"2025-01-20T20:48:11","slug":"assignment-5","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/assignments\/assignment-5\/","title":{"rendered":"Assignment 5"},"content":{"rendered":"\n

<\/span>Linked Lists With Polymorphism<\/span><\/h3>\n\n\n\n

<\/span>Why More About Linked Lists?<\/em><\/span><\/h4>\n\n\n\n

So you thought you’d seen all you ever wanted to know about linked lists after the last assignment? Read on…<\/p>\n\n\n\n

While the previous design worked (at least if you implemented it right…), it had its drawbacks. Let’s list some of them:<\/p>\n\n\n\n

    \n
  • The list classes were very generic. In particular, there was no type checking to provide compile-time checking to prevent mistakes. For example, imagine you had a list item that represented a\u00a0Person<\/strong>\u00a0and put it into a list, and then you navigated the list assuming that the list items represented\u00a0Fruit<\/strong>\u00a0or a\u00a0Wine<\/strong>\u00a0— something other than a\u00a0Person<\/strong>. You have to\u00a0typecast<\/em>\u00a0the data from the list item from a\u00a0void *<\/strong>\u00a0to some other kind of pointer (having to typecast all the time can become a real pain, and it’s very error-prone). Because there is no type-checking at compile time, your program will likely compile and link without problems. There is also no run-time type-checking, so you will likely get very strange results when you run your program. Even if you don’t see anything obvious (like an access violation, core dump, or GPF), there’s usually something evil going on under the surface. In fact, if you don’t see something wrong, that’s probably the time to start worrying, because you don’t even know where to start looking. What’s more it’s usually a real bear to debug and fix these kinds of problems, even if you do see the symptoms.<\/li>\n\n\n\n
  • There was no support for homogeneous lists — lists which can only contain items that represent a single type. What if you wanted to ensure that all the items in a list represented\u00a0Person<\/strong>s? Or that they all represented\u00a0Wine<\/strong>s? There is no type-checking of that, at all — again, neither at compile-time nor at run-time.<\/li>\n\n\n\n
  • Even the support for heterogeneous lists wasn’t that great. While you often need to have a list of things that are of identical type, it’s rare that you have a use for a list that can contain absolutely anything. More likely, you will have a list of related, or similar, items. For example, in a payroll application, you might have a list of\u00a0Manager<\/strong>s,\u00a0Secretary<\/strong>s,\u00a0Programmer<\/strong>s,\u00a0Janitor<\/strong>s — yes, even\u00a0VicePresident<\/strong>s and the\u00a0ChairmanOfTheBoard<\/strong>\u00a0(yes, even they get paid!). They are of different types, but they are all\u00a0related<\/em>\u00a0to each other — they are all\u00a0Employee<\/strong>s. If you wish to ensure that only\u00a0Employee<\/strong>s (of whatever job description) may be contained in a list, the previous design doesn’t help you much.<\/li>\n\n\n\n
  • That pesky\u00a0ListItem<\/strong>\u00a0class being separate from the data it represents is a real pain in the, er… Well, it’s very clumsy and inconvenient. Couldn’t we integrate it into the class that we wish to place in the list?<\/li>\n<\/ul>\n\n\n\n

    These shortcomings mostly boil down to lack of safety and convenience. It’s hard enough work to come up a well-designed, solid and well-tested application.  Why can’t the compiler help a little more, and then maybe you’d get home on time at least once a week? Well, it can, but you have to do some of the work — more design. An investment in the proper up-front design can pay great dividends in making it easier to implement that design, and that can translate into less work (time, money…) to implement and test that design.<\/p>\n\n\n\n

    Let’s take a look at what we might do to improve things…<\/p>\n\n\n\n

    <\/span>Design Alternatives<\/em><\/span><\/h4>\n\n\n\n

    Here are a couple of ideas on how we might be able to improve matters:<\/p>\n\n\n\n

      \n
    1. Have a\u00a0ListItem<\/strong>\u00a0actually contain, rather than point to, the data it represents.<\/li>\n\n\n\n
    2. Change every\u00a0void *<\/strong>\u00a0to a specific pointer type. This would allow you to have a homogeneous list, and would add the necessary type-checking.<\/li>\n<\/ol>\n\n\n\n

      Well, they’re fine and dandy as ideas go, but both of them move us away from the idea that you would like to write the code for a list once<\/em>, and then use it for whatever you wish to place in that list.<\/p>\n\n\n\n

      For example, let’s say that you decided to have a ListItem<\/strong> contain<\/em> a Person<\/strong>. Then you could place the ListItem<\/strong> in a List<\/strong> and (with the appropriate member functions) manipulate the List<\/strong> with the full knowledge that it can only contain Person<\/strong>s. With the proper code, you would also get type-checking, so you could detect at compile-time when you (or someone who uses your code) make a stupid mistake.<\/p>\n\n\n\n

      But what if you also wanted to make a List<\/strong> of Wine<\/strong>s? and a List<\/strong> of Fruit<\/strong>s? and a List<\/strong> of Employee<\/strong>s? Then you would have to create a PersonListItem<\/strong>, and a WineListItem<\/strong>, and a FruitListItem<\/strong>, and.– you get the picture… Not only that, to make it all consistent, you would have create a new List<\/strong> class and a new ListIterator<\/strong> class for each type of ListItem<\/strong> derivative you invent.<\/p>\n\n\n\n

      Sure, you could simply cut and paste the code to create new classes each time, with the appropriate changes in types, but what if someone found a bug in the original implementation? Could you reliably find all the places you’d cut and pasted the code to, and fix that bug everywhere it exists? Multiply that bug by a thousand or more, and the number of places to find each instance of each bug, and you might get a feeling for the problem you’re creating for yourself. (It’s called the most primitive form of code reuse — cut, paste and hope the original doesn’t break, and that you don’t introduce new bugs in the copied version as you make changes.)<\/p>\n\n\n\n

      Well, this problem is really solved in C++ by template classes<\/em>. Unfortunately, there are two problems with template classes:<\/p>\n\n\n\n

        \n
      1. We haven’t got to that topic in the course. Be warned that it’s a complex and advanced topic. On the other hand, the ISO C++ standard includes STL (the Standard Template Library), a very important\u00a0generic programming<\/em>\u00a0library, which uses templates all over the place. Much of the C++ standard class library has been redefined and re-implemented using STL and templates, and so it’s a road we will all have to take eventually.<\/li>\n\n\n\n
      2. Templates have historically been one of the most troublesome areas of C++. The ISO C++ standards committee wrestled with them for a long time, and came up with merely a compromise solution to some of the problems. Different C++ compilers have implemented templates in different ways, and with different features. So compatibility and portability across platforms used to be a big issue when it comes to C++ templates. This problem has mostly gone away, now that the ISO C++ standards committee has finally published the C++ standard. <\/li>\n<\/ol>\n\n\n\n

        Phew! That said, what are we going to do in the absence of templates?<\/p>\n\n\n\n

        <\/span>Containment<\/em><\/span><\/h4>\n\n\n\n

        Well, first, take a look at a technique that I used in the previous assignment, in the list of Person<\/strong>s. I’ll reproduce it here, so you don’t have to flip pages or browse to it and back:<\/p>\n\n\n\n

        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  Person.h<\/span><\/span>\n\/\/  Assignment 4: Linked Lists<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/31\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Person_h<\/span><\/span>\n#define<\/span> Person_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><string><\/span><\/span>\nusing<\/span> <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"List.h"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Person<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Person<\/span>(<\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>name<\/span>);<\/span><\/span>\n  <\/span>Person<\/span>(<\/span>const<\/span> <\/span>Person<\/span> <\/span>&<\/span>person<\/span>);<\/span><\/span>\n  <\/span>~Person<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>Name<\/span>() <\/span>const<\/span><\/span>\n  {<\/span><\/span>\n      <\/span>return<\/span> m_name;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Add<\/span>(<\/span>List<\/span> <\/span>&<\/span>list<\/span>, <\/span>Person<\/span> <\/span>*<\/span>prevPerson<\/span>);<\/span><\/span>\n  <\/span>void<\/span> <\/span>Remove<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\n<\/span>\n  \/\/ Assignment operator<\/span><\/span>\n  <\/span>Person<\/span> <\/span>&<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>Person<\/span> <\/span>&<\/span>person<\/span>);<\/span><\/span>\n<\/span>\n  \/\/ Conversion function to ListItem &<\/span><\/span>\n  <\/span>operator<\/span> <\/span>ListItem<\/span> <\/span>&<\/span>()<\/span><\/span>\n  {<\/span><\/span>\n      <\/span>return<\/span> m_item;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  ListItem  m_item;<\/span><\/span>\n  string    m_name;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Person_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        \n
        Note that here, instead of having the ListItem<\/strong> class contain an instance of class Person<\/strong>, class Person<\/strong> contains an instance of class ListItem<\/strong>. Kind of inside out thinking, don’t you think?<\/p>\n\n\n\n
        This was a reasonable solution, except for one thorny problem: How, given an instance of class Person<\/strong>, do I treat that class like a ListItem<\/strong>, so it can be placed in the List<\/strong>? My solution was to introduce into the Person<\/strong> class a conversion function<\/strong><\/em>:<\/p>\n\n\n\n
        operator ListItem &() { return m_item; }<\/strong><\/code><\/pre>\n\n\n\n
        which allows an instance of class\u00a0Person<\/strong>\u00a0to be ‘converted’ to an instance of class\u00a0ListItem<\/strong>. In this case, all this means is that the conversion function returns a reference to\u00a0m_item<\/strong>, the\u00a0ListItem<\/strong> instance contained within the\u00a0Person<\/strong>\u00a0class. With this, I can write code like:<\/p>\n\n\n\n
        list.Append(person[i]);<\/strong><\/code><\/pre>\n\n\n\n
        and have the conversion function do its silent work, making it look like I’m adding a Person<\/strong> to the list. In addition, I added some additional member functions to class Person<\/strong>:<\/p>\n\n\n\n
        void Add(List &list, Person *prevPerson);\nvoid Remove();<\/strong><\/code><\/pre>\n\n\n\n
        which allow us to add and remove instances of class Person<\/strong> from a List<\/strong>, while providing type-safety (meaning that I know that I’m adding instances of Person<\/strong> to the list). Note that these new member functions are implemented using the existing ListItem<\/strong> member functions. They merely hide the details from users of the Person<\/strong> class, and also provide the stronger typing..<\/p>\n\n\n\n
        However, this code does not prevent a malicious or underachieving programmer from using the bare ListItem<\/strong> class. And we still have the problem of List<\/strong> and ListIterator<\/strong> knowing nothing about the Person<\/strong> class.<\/p>\n<\/div>\n<\/div>\n\n\n\n
        We could, of course, apply the same techniques to the List<\/strong> and ListIterator<\/strong> classes to produce PersonList<\/strong> and PersonIterator<\/strong> classes. <\/p>\n\n\n\n
        But we won’t, because there’s a better way — using inheritance<\/em> and polymorphism<\/em>.<\/p>\n\n\n\n
        <\/span>The Assignment (Step 1)<\/em><\/span><\/h3>\n\n\n\n
        <\/span>Preparing for Polymorphism<\/em><\/span><\/h4>\n\n\n\n
        Here’s where you get to do some of the work:<\/strong><\/em><\/p>\n\n\n\n
        First, make a copy of your original linked list classes, and create a new project to put the copies in. You can always go back to the old project if you want to have a taste of something that still works — we’re going to be making some changes that will initially stop things from working, and you may get frustrated for a while — bear with me!<\/p>\n\n\n\n
        <\/span>Making the List Classes (pseudo-)Abstract<\/em><\/span><\/h4>\n\n\n\n
        Now, let’s make some changes to the list classes to make them (sort of) abstract. Remember, an abstract class is one that cannot be instantiated by itself. For example, you might choose to make a Fish<\/strong> class abstract, since it’s very generic. If asked to make an instance of class Fish<\/strong>, the first question you’d be likely to ask is “What kind of fish would you like?”. Haddock<\/strong>, or Flounder<\/strong> would be good, but Fish<\/strong> is kind of non-specific. Making a class abstract highlights the fact that you can’t really make an instance of that class, because you need more information.<\/p>\n\n\n\n
        Conventionally, we make a C++ class abstract by introducing into that class a pure virtual function<\/em>. However, for the moment, at least, I’m not going to do that. Instead, I’ll take a different approach so that I can introduce some different ideas and techniques.<\/p>\n\n\n\n
        \n
        Note:<\/strong><\/em>\u00a0We’re going to be moving things around inside the classes to make access to them more restricted. If you look at my original class definitions, you’ll see that I placed the sections in each class so that\u00a0public<\/strong>\u00a0member functions come\u00a0first<\/strong><\/em>, while\u00a0private<\/strong>\u00a0member functions and data members\u00a0(remember, data members should always be\u00a0private<\/strong><\/em>)\u00a0<\/strong>come\u00a0last<\/strong><\/em>, at the end. Why? To the clients of a class, the most important members are its\u00a0public<\/strong>\u00a0ones. Ideally, the clients of a class should have no interest in, and certainly not depend on, the\u00a0private<\/strong>\u00a0parts of a class.<\/p>\n\n\n\n
        We will be adding a protected<\/strong> section within the class. I place the protected<\/strong> section between<\/strong><\/em> the public<\/strong> and private<\/strong> sections. I strongly<\/strong><\/em> suggest you follow this convention.<\/p>\n<\/blockquote>\n\n\n\n
        Here’s what to do:<\/strong><\/p>\n\n\n\n
          \n
        1. In the\u00a0List<\/strong>\u00a0class:
          1. Move<\/em>\u00a0the constructor,\u00a0List()<\/strong>, and the member functions,\u00a0void Append(ListItem &item)<\/strong>,\u00a0\u00a0ListItem *GetFirst() const<\/strong>, and\u00a0ListItem *GetLast() const<\/strong>, into a\u00a0\u00a0protected<\/strong>\u00a0section of the class.<\/li>
          2. Make<\/em>\u00a0the destructor\u00a0virtual<\/strong>.<\/li><\/ol>This should leave only the destructor and the member functions\u00a0GetCount()<\/strong>,\u00a0Purge()<\/strong>, and\u00a0Dump()<\/strong>\u00a0public\u00a0within the\u00a0List<\/strong>\u00a0class.<\/li>\n\n\n\n
          3. In the\u00a0ListItem<\/strong>\u00a0class:
            1. Move<\/em>\u00a0the constructor,\u00a0ListItem(void *data)<\/strong>, and the member functions\u00a0ListItem *GetNext() const<\/strong>,\u00a0\u00a0ListItem *GetPrevious() const<\/strong>, and\u00a0void Add(List &list, ListItem *prevItem)<\/strong>\u00a0into a\u00a0protected<\/strong>\u00a0section of the class.<\/li>
            2. Remove<\/em>\u00a0the member function\u00a0void *GetData()<\/strong>, and the data member\u00a0m_data<\/strong>.<\/li>
            3. Change<\/em>\u00a0the constructor to\u00a0ListItem()<\/strong>\u00a0— that is, remove the\u00a0void *data<\/strong>\u00a0argument.<\/li>
            4. Make<\/em>\u00a0the destructor\u00a0virtual<\/strong>.<\/li><\/ol>This should leave only the destructor and the member functions\u00a0Remove(), GetList()<\/strong>, and\u00a0Dump()<\/strong>\u00a0public\u00a0within the\u00a0ListItem<\/strong>\u00a0class.<\/li>\n\n\n\n
            5. In the\u00a0ListIterator<\/strong>\u00a0class:
              1. Move<\/em>\u00a0the constructor,\u00a0ListIterator(List &list)<\/strong>, and the member functions\u00a0ListItem *GetCurrent()<\/strong>,\u00a0ListItem *GetNext(), ListItem *GetPrevious()<\/strong>\u00a0into a\u00a0protected<\/strong>\u00a0section of the class.<\/li>
              2. Make<\/em>\u00a0the destructor\u00a0virtual<\/strong>.<\/li><\/ol>This should leave only the destructor and the member functions\u00a0bool AtFirst() const<\/strong>, and\u00a0bool AtLast() const<\/strong>\u00a0public\u00a0within the\u00a0ListIterator<\/strong>\u00a0class.<\/li>\n<\/ol>\n\n\n\n
                Now try compiling the result. [Hmmmm…. A few compile-time errors, huh? Not to worry, it’s expected.]<\/strong><\/em><\/p>\n\n\n\n
                In order to get the list.cpp<\/strong> file to compile, you will have to add one or two friendship relationships among the three list classes. You should not have to change any code in list.cpp<\/strong> to make it compile — only the changes I specified above in list.h<\/strong>.<\/p>\n\n\n\n
                However, you should expect the other .cpp files\u00a0not<\/em>\u00a0to compile at this point.<\/p>\n\n\n\n
                For example, the line in file test.cpp<\/strong>:<\/p>\n\n\n\n
                List list;<\/strong><\/code><\/pre>\n\n\n\n
                will produce errors. Why?\u00a0<\/p>\n\n\n\n
                <\/span>The Assignment (Step 2)<\/em><\/span><\/h3>\n\n\n\n
                <\/span>Using our Newly (pseudo-)Abstract Classes<\/strong><\/em><\/span><\/h4>\n\n\n\n
                So how are we going to use our new List<\/strong>, ListItem<\/strong>, and ListIterator<\/strong> classes?<\/p>\n\n\n\n
                Well, we’re not, directly. We’ll use them indirectly<\/em>, by writing modified Wine<\/strong> and Person<\/strong> classes. In fact, for each one, we’ll write a set of classes, derived from ListItem<\/strong>, List<\/strong>, and ListIterator<\/strong>. In this way, we can create Person-specific and Wine-specific versions of our List classes, while using inheritance to ensure that we share the code that implements the lists. At the same time, we now have classes that are strongly-typed<\/em>.<\/p>\n\n\n\n
                I think you’ll start to see how this approach can simplify the code you have to write to use these classes. For a start, you no longer have to typecast the data into the proper type; that’s done for you by the Person-specific and Wine-specific classes.<\/p>\n\n\n\n
                To give you a head start, here is the modified header file for\u00a0Person<\/strong>,\u00a0person.h<\/strong>. Class\u00a0Person<\/strong>\u00a0no longer contains a\u00a0ListItem<\/strong>\u00a0member, but instead inherits (publicly!) from\u00a0ListItem<\/strong>.<\/p>\n\n\n\n
                \n
                \n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  Person.h<\/span><\/span>\n\/\/  Assignment 5: Linked Lists with Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 11\/1\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Person_h<\/span><\/span>\n#define<\/span> Person_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><string><\/span><\/span>\nusing<\/span> <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"List.h"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>PersonList<\/span>;<\/span> \/\/ Forward declaration<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Person<\/span> : <\/span>public<\/span> <\/span>ListItem<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Person<\/span>(<\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>name<\/span>);<\/span><\/span>\n  <\/span>Person<\/span>(<\/span>const<\/span> <\/span>Person<\/span> <\/span>&<\/span>person<\/span>);<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~Person<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>Name<\/span>() <\/span>const<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>return<\/span> m_name;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Add<\/span>(<\/span>PersonList<\/span> <\/span>&<\/span>list<\/span>, <\/span>Person<\/span> <\/span>*<\/span>prevPerson<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\n<\/span>\n  \/\/ Assignment operator<\/span><\/span>\n  <\/span>Person<\/span> <\/span>&<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>Person<\/span> <\/span>&<\/span>person<\/span>);<\/span><\/span>\n  <\/span><\/span>\n  <\/span>Person<\/span> <\/span>&<\/span>GetNext<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>Person<\/span> <\/span>&<\/span>GetPrevious<\/span>() <\/span>const<\/span>;<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  string m_name;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ PersonList<\/span><\/span>\nclass<\/span> <\/span>PersonList<\/span> : <\/span>public<\/span> <\/span>List<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>PersonList<\/span>() {}<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~PersonList<\/span>() {}<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Append<\/span>(<\/span>Person<\/span> <\/span>&<\/span>person<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>Person<\/span> <\/span>*<\/span>GetFirst<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>Person<\/span> <\/span>*<\/span>GetLast<\/span>() <\/span>const<\/span>;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ PersonIterator<\/span><\/span>\nclass<\/span> <\/span>PersonIterator<\/span> : <\/span>public<\/span> <\/span>ListIterator<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>PersonIterator<\/span>(<\/span>PersonList<\/span> <\/span>&<\/span>list<\/span>);<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~PersonIterator<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>Person<\/span> <\/span>*<\/span>GetCurrent<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>Person<\/span> <\/span>*<\/span>GetNext<\/span>();<\/span><\/span>\n  <\/span>Person<\/span> <\/span>*<\/span>GetPrevious<\/span>();<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Person_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                \n
                Note that I have removed all traces of List<\/code><\/strong>, ListItem<\/code><\/strong>, or ListIterator<\/code><\/strong> from the public interfaces of these classes. The intent it to implement all the functionality of the Person<\/code><\/strong> classes using the functionality provided by those underlying list classes, without exposing that fact to the outside world.<\/p>\n<\/div>\n<\/div>\n\n\n\n
                <\/span>Here’s What to Do:<\/strong><\/em><\/span><\/h4>\n\n\n\n
                <\/span>Person<\/span><\/h5>\n\n\n\n
                Implement class Person<\/strong>, in person.cpp<\/strong>.<\/p>\n\n\n\n
                Here is a test program to run your Person<\/strong> class through its paces:<\/p>\n\n\n\n
                \n
                \n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  TestPerson.cpp<\/span><\/span>\n\/\/  Assignment 5: Linked Lists with Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 11\/1\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\nusing<\/span> <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Person.h"<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>display<\/span>(<\/span>PersonList<\/span> <\/span>&<\/span>list<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  cout << <\/span>"Contents of list:"<\/span> << endl;<\/span><\/span>\n  PersonIterator <\/span>iter<\/span>(list);<\/span><\/span>\n  <\/span>for<\/span> (Person *person = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       person != <\/span>0<\/span>;<\/span><\/span>\n       person = <\/span>iter<\/span>.<\/span>GetNext<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>person<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  cout << <\/span>"-----Dump------"<\/span> << endl;<\/span><\/span>\n  <\/span>list<\/span>.<\/span>Dump<\/span>();<\/span><\/span>\n  cout << <\/span>"---End Dump----"<\/span> << endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>ListPersons<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Person <\/span>fred<\/span>(<\/span>"Fred"<\/span>);<\/span><\/span>\n  Person <\/span>mary<\/span>(<\/span>"Mary"<\/span>);<\/span><\/span>\n  Person <\/span>joe<\/span>(<\/span>"Joe"<\/span>);<\/span><\/span>\n  Person <\/span>clive<\/span>(<\/span>"Clive"<\/span>);<\/span><\/span>\n  Person <\/span>nigel<\/span>(<\/span>"Nigel"<\/span>);<\/span><\/span>\n  Person <\/span>nostradamus<\/span>(<\/span>"Nostradamus"<\/span>);<\/span><\/span>\n  Person <\/span>einstein<\/span>(<\/span>"Einstein"<\/span>);<\/span><\/span>\n<\/span>\n  Person *items[] = { &fred, &mary, &joe, &clive,<\/span><\/span>\n                      &nigel, &nostradamus, &einstein };<\/span><\/span>\n<\/span>\n  Person *person;<\/span><\/span>\n<\/span>\n  PersonList list;<\/span>      \/\/ The list of people<\/span><\/span>\n<\/span>\n  \/\/ The following List iterator is positioned so that<\/span><\/span>\n  \/\/ the list it associates with is empty at the time<\/span><\/span>\n  \/\/ of the association.<\/span><\/span>\n  PersonIterator <\/span>iter<\/span>(list);<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Start testing<\/span><\/span>\n<\/span>\n  cout << <\/span>"Empty list..."<\/span> << endl;<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Append"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Appending: "<\/span>;<\/span><\/span>\n  <\/span>fred<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>list<\/span>.<\/span>Append<\/span>(fred);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing a second Append"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Appending: "<\/span>;<\/span><\/span>\n  <\/span>nigel<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>list<\/span>.<\/span>Append<\/span>(nigel);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Add to front"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Adding: "<\/span>;<\/span><\/span>\n  <\/span>mary<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>mary<\/span>.<\/span>Add<\/span>(list, <\/span>0<\/span>);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Add to end"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Adding: "<\/span>;<\/span><\/span>\n  <\/span>joe<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>joe<\/span>.<\/span>Add<\/span>(list, <\/span>list<\/span>.<\/span>GetLast<\/span>());<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Add to middle"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Adding: "<\/span>;<\/span><\/span>\n  <\/span>clive<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>clive<\/span>.<\/span>Add<\/span>(list, &mary);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"------------Iterator testing------------"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>"Testing iterator originally set on empty list..."<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (person = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       person != <\/span>0<\/span>;<\/span><\/span>\n       person = <\/span>iter<\/span>.<\/span>GetNext<\/span>())<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>person<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  cout << <\/span>"Now reversing direction on iterator..."<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (person = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       person != <\/span>0<\/span>;<\/span><\/span>\n       person = <\/span>iter<\/span>.<\/span>GetPrevious<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>person<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  cout << <\/span>"Reversing direction again..."<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (person = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       person != <\/span>0<\/span>;<\/span><\/span>\n       person = <\/span>iter<\/span>.<\/span>GetNext<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>person<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n  cout << <\/span>"--------End Iterator testing------------"<\/span> << endl;<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal from middle"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  <\/span>clive<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>clive<\/span>.<\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal from end"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  <\/span>joe<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>joe<\/span>.<\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n    cout << <\/span>"Testing removal from front"<\/span> << endl;<\/span><\/span>\n    cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n    <\/span>mary<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n    <\/span>mary<\/span>.<\/span>Remove<\/span>();<\/span><\/span>\n    <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal from end"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  <\/span>nigel<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>nigel<\/span>.<\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal of last item"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  <\/span>fred<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n  <\/span>fred<\/span>.<\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  \/\/ Finally, we test the actions of the List destructor<\/span><\/span>\n<\/span>\n  \/\/ First, go through the items to check that they are not in<\/span><\/span>\n  \/\/ a list...<\/span><\/span>\n  cout << <\/span>"Checking that removed items do not appear to be in a list"<\/span> << endl;<\/span><\/span>\n  <\/span>int<\/span> len = <\/span>sizeof<\/span>(items)\/<\/span>sizeof<\/span>(<\/span>items<\/span>[<\/span>0<\/span>]);<\/span><\/span>\n  <\/span>int<\/span> elem;<\/span><\/span>\n  <\/span>int<\/span> errors = <\/span>0<\/span>;<\/span><\/span>\n  <\/span>for<\/span> (elem = <\/span>0<\/span>; elem < len; elem++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetList<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still in a list"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetNext<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a next ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetPrevious<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a previous ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n    <\/span><\/span>\n  \/\/ Now, create the list and populate it from the items<\/span><\/span>\n  cout << <\/span>"Checking addition and removal to a dynamic list"<\/span> << endl;<\/span><\/span>\n  PersonList *dynList = <\/span>new<\/span> <\/span>PersonList<\/span>();<\/span><\/span>\n  <\/span>for<\/span> (elem = len-<\/span>1<\/span>; elem >= <\/span>0<\/span>; elem--)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>dynList<\/span>-><\/span>Append<\/span>(*(<\/span>items<\/span>[elem]));<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Display the list for validation<\/span><\/span>\n  <\/span>display<\/span>(*dynList);<\/span><\/span>\n<\/span>\n  \/\/ Now destroy the list and examine the state of each<\/span><\/span>\n  \/\/ of the items that were in the list<\/span><\/span>\n  cout << <\/span>"Destroying dynamic list"<\/span> << endl;<\/span><\/span>\n  <\/span>delete<\/span> dynList;<\/span><\/span>\n  cout << <\/span>"Checking that removed items do not appear to be in a list"<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (elem = <\/span>0<\/span>; elem < len; elem++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetList<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still in a list"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetNext<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a next ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetPrevious<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a previous ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n  cout << errors << <\/span>" errors detected"<\/span> << endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>ListPersons<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                \n
                \n
                Note:<\/em>\u00a0<\/strong>Of course, the program should work correctly. So test it, and show me the results.<\/p>\n<\/blockquote>\n\n\n\n
                \n
                Warning:<\/em>\u00a0<\/strong>Do\u00a0not<\/em>\u00a0simply copy the code from\u00a0List<\/code><\/strong>,\u00a0ListItem<\/code><\/strong>, and\u00a0ListIterator<\/strong><\/code>\u00a0into the\u00a0Person<\/code><\/strong>\u00a0and\u00a0Wine<\/code><\/strong>\u00a0classes! This would be to miss the whole point of the exercise! You would not be benefiting from the code reuse you get from a single implementation of the code!<\/p>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
                <\/span>Wine<\/span><\/h5>\n\n\n\n
                Implement a corresponding set of classes for class Wine<\/strong>, in wine.h<\/strong> and wine.cpp<\/strong>.<\/p>\n\n\n\n
                Here is a test program to run your Wine<\/strong> class through its paces:<\/p>\n\n\n\n
                \n
                \n
                <\/path><\/path><\/svg><\/span>
                \/\/<\/span><\/span>\n\/\/  TestWines.cpp<\/span><\/span>\n\/\/  Assignment 5: Linked Lists with Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 11\/1\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><cstdlib><\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\nusing<\/span> <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Wine.h"<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>display<\/span>(<\/span>WineList<\/span> <\/span>&<\/span>list<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  cout << <\/span>"Contents of list:"<\/span> << endl;<\/span><\/span>\n  WineIterator <\/span>iter<\/span>(list);<\/span><\/span>\n  <\/span>for<\/span> (Wine *wine = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       wine != <\/span>0<\/span>;<\/span><\/span>\n       wine = <\/span>iter<\/span>.<\/span>GetNext<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n      <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  cout << <\/span>"-----Dump------"<\/span> << endl;<\/span><\/span>\n  <\/span>list<\/span>.<\/span>Dump<\/span>();<\/span><\/span>\n  cout << <\/span>"---End Dump----"<\/span> << endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>ListWines<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  Wine <\/span>beaujolais<\/span>(<\/span>"Beaujolais"<\/span>, <\/span>1970<\/span>);<\/span><\/span>\n  Wine <\/span>amontillado<\/span>(<\/span>"Amontillado"<\/span>, <\/span>1964<\/span>);<\/span><\/span>\n  Wine <\/span>riesling<\/span>(<\/span>"Riesling"<\/span>, <\/span>1980<\/span>);<\/span><\/span>\n  Wine <\/span>gewurztraminer<\/span>(<\/span>"Gewurztraminer"<\/span>, <\/span>1993<\/span>);<\/span><\/span>\n  Wine <\/span>shiraz<\/span>(<\/span>"Shiraz"<\/span>, <\/span>2003<\/span>);<\/span><\/span>\n  Wine <\/span>cabernet<\/span>(<\/span>"Cabernet Sauvignon"<\/span>, <\/span>2001<\/span>);<\/span><\/span>\n<\/span>\n  \/\/ Each item in the following list is an instance<\/span><\/span>\n  \/\/ of ListItem, each pointing to its corresponding<\/span><\/span>\n  \/\/ Wine instance.<\/span><\/span>\n  Wine *items[] = { &beaujolais, &amontillado,<\/span><\/span>\n                    &riesling,   &gewurztraminer,<\/span><\/span>\n                    &shiraz,     &cabernet };<\/span><\/span>\n<\/span>\n  Wine *wine;<\/span>     \/\/ Wine pointer used in many places<\/span><\/span>\n<\/span>\n  WineList list;<\/span>  \/\/ The list of wines<\/span><\/span>\n<\/span>\n  \/\/ The following List iterator is positioned so that<\/span><\/span>\n  \/\/ the list it associates with is empty at the time<\/span><\/span>\n  \/\/ of the association.<\/span><\/span>\n  WineIterator <\/span>iter<\/span>(list);<\/span><\/span>\n<\/span>\n  \/\/ Start testing<\/span><\/span>\n<\/span>\n  cout << <\/span>"Empty list..."<\/span> << endl;<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Append"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Appending: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>0<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>list<\/span>.<\/span>Append<\/span>(*<\/span>items<\/span>[<\/span>0<\/span>]);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing a second Append"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Appending: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>4<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>list<\/span>.<\/span>Append<\/span>(*<\/span>items<\/span>[<\/span>4<\/span>]);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Add to front"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Adding: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>1<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>1<\/span>]-><\/span>Add<\/span>(list, <\/span>NULL<\/span>);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Add to end"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Adding: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>2<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>2<\/span>]-><\/span>Add<\/span>(list, <\/span>list<\/span>.<\/span>GetLast<\/span>());<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing Add to middle"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Adding: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>3<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>3<\/span>]-><\/span>Add<\/span>(list, <\/span>items<\/span>[<\/span>1<\/span>]);<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"------------Iterator testing------------"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>"Testing iterator originally set on empty list..."<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (wine = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       wine != <\/span>0<\/span>;<\/span><\/span>\n       wine = <\/span>iter<\/span>.<\/span>GetNext<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  cout << <\/span>"Now reversing direction on iterator..."<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (wine = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       wine != <\/span>0<\/span>;<\/span><\/span>\n       wine = <\/span>iter<\/span>.<\/span>GetPrevious<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  cout << <\/span>"Reversing direction again..."<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (wine = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       wine != <\/span>0<\/span>;<\/span><\/span>\n       wine = <\/span>iter<\/span>.<\/span>GetNext<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n  cout << <\/span>"--------End Iterator testing------------"<\/span> << endl;<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal from middle"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>3<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>3<\/span>]-><\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal from end"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>2<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>2<\/span>]-><\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal from front"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>1<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>1<\/span>]-><\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal from end"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>4<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>4<\/span>]-><\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  cout << <\/span>"Testing removal of last item"<\/span> << endl;<\/span><\/span>\n  cout << <\/span>" Removing: "<\/span>;<\/span><\/span>\n  wine = <\/span>items<\/span>[<\/span>0<\/span>];<\/span><\/span>\n  <\/span>wine<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  <\/span>items<\/span>[<\/span>0<\/span>]-><\/span>Remove<\/span>();<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n<\/span>\n  \/\/ Finally, we test the actions of the List destructor<\/span><\/span>\n<\/span>\n  \/\/ First, go through the items to check that they are not in<\/span><\/span>\n  \/\/ a list...<\/span><\/span>\n  cout << <\/span>"Checking that removed items do not appear to be in a list"<\/span> << endl;<\/span><\/span>\n  <\/span>int<\/span> len = <\/span>sizeof<\/span>(items)\/<\/span>sizeof<\/span>(<\/span>items<\/span>[<\/span>0<\/span>]);<\/span><\/span>\n  <\/span>int<\/span> elem;<\/span><\/span>\n  <\/span>int<\/span> errors = <\/span>0<\/span>;<\/span><\/span>\n  <\/span>for<\/span> (elem = <\/span>0<\/span>; elem < len; elem++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetList<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still in a list"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetNext<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a next ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetPrevious<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a previous ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n    <\/span><\/span>\n  \/\/ Now, create the list and populate it from the items<\/span><\/span>\n  cout << <\/span>"Checking addition and removal to a dynamic list"<\/span> << endl;<\/span><\/span>\n  WineList *dynList = <\/span>new<\/span> <\/span>WineList<\/span>();<\/span><\/span>\n  <\/span>for<\/span> (elem = len-<\/span>1<\/span>; elem >= <\/span>0<\/span>; elem--)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>dynList<\/span>-><\/span>Append<\/span>(*<\/span>items<\/span>[elem]);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\n  \/\/ Display the list for validation<\/span><\/span>\n  <\/span>display<\/span>(*dynList);<\/span><\/span>\n<\/span>\n  \/\/ Now destroy the list and examine the state of each<\/span><\/span>\n  \/\/ of the items that were in the list<\/span><\/span>\n  cout << <\/span>"Destroying dynamic list"<\/span> << endl;<\/span><\/span>\n  <\/span>delete<\/span> dynList;<\/span><\/span>\n  cout << <\/span>"Checking that removed items do not appear to be in a list"<\/span> << endl;<\/span><\/span>\n  <\/span>for<\/span> (elem = <\/span>0<\/span>; elem < len; elem++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetList<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still in a list"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetNext<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a next ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>items<\/span>[elem]-><\/span>GetPrevious<\/span>() != <\/span>0<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n      errors++;<\/span><\/span>\n      cerr << <\/span>"Element "<\/span> << elem << <\/span>" still has a previous ptr"<\/span> << endl;<\/span><\/span>\n    }<\/span><\/span>\n  }<\/span><\/span>\n  cout << errors << <\/span>" errors detected"<\/span> << endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>ListWines<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                <\/div>\n<\/div>\n\n\n\n
                <\/span>The Assignment (Step 3)<\/em><\/span><\/h3>\n\n\n\n
                <\/span>Supporting Heterogeneous Lists of Related Items<\/em><\/span><\/h4>\n\n\n\n
                The above changes improved matters somewhat:<\/p>\n\n\n\n
                  \n
                1. Homogeneous lists are now easier to implement (if a little repetitious)<\/li>\n\n\n\n
                2. We now have strong typing, and no need for typecasting in our main code. (If you have any such typecasting in the code your wrote outside of the\u00a0Person<\/strong>\u00a0and\u00a0Wine<\/strong>\u00a0classes, then you need to check it;\u00a0 it’s probably incorrect and\/or unnecessary.)<\/li>\n<\/ol>\n\n\n\n
                  However, we don’t yet have support for the kind of heterogeneous list that contains items which are not all identical types, but which are related to each other (as in the Employees example, earlier). So let’s see what we can do to make this possible:<\/p>\n\n\n\n
                  First, let’s come up with a set of related classes: Employee<\/strong>, Manager<\/strong>, and Secretary<\/strong>. Note that Employee<\/strong> is derived from Person<\/strong>, and has related classes EmployeeList<\/strong> and EmployeeIterator<\/strong>, while Manager<\/strong> and Secretary<\/strong> are simply derived from Employee<\/strong>, and do not have their own list or iterator. With this infrastructure, we can support a heterogeneous list of items which are related to each other: they are all Employees<\/strong>.<\/p>\n\n\n\n
                  \n
                  \n
                  <\/path><\/path><\/svg><\/span>
                  \/\/<\/span><\/span>\n\/\/  Employee.h<\/span><\/span>\n\/\/  Assignment 5: Linked Lists with Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 11\/1\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> Employee_h<\/span><\/span>\n#define<\/span> Employee_h<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><string><\/span><\/span>\nusing<\/span> <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Person.h"<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>EmployeeList<\/span>;<\/span><\/span>\n<\/span>\n\/\/ Employee<\/span><\/span>\nclass<\/span> <\/span>Employee<\/span> : <\/span>public<\/span> <\/span>Person<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Employee<\/span>(<\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>name<\/span>, <\/span>double<\/span> <\/span>salary<\/span>);<\/span><\/span>\n  <\/span>Employee<\/span>(<\/span>const<\/span> <\/span>Employee<\/span> <\/span>&<\/span>emp<\/span>);<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~Employee<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Add<\/span>(<\/span>EmployeeList<\/span> <\/span>&<\/span>list<\/span>, <\/span>Employee<\/span> <\/span>*<\/span>prevEmployee<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>GetPosition<\/span>() <\/span>const<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>return<\/span> m_position;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\nprotected:<\/span><\/span>\n  <\/span>void<\/span> <\/span>SetPosition<\/span>(<\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>position<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    m_position = position;<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  <\/span>double<\/span> m_salary;<\/span><\/span>\n<\/span>\n  string m_position;<\/span> \/\/ Name of position in organization<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ EmployeeList<\/span><\/span>\nclass<\/span> <\/span>EmployeeList<\/span> : <\/span>public<\/span> <\/span>PersonList<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>EmployeeList<\/span>();<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~EmployeeList<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Append<\/span>(<\/span>Employee<\/span> <\/span>&<\/span>emp<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>Employee<\/span> <\/span>*<\/span>GetFirst<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>Employee<\/span> <\/span>*<\/span>GetLast<\/span>() <\/span>const<\/span>;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ EmployeeIterator<\/span><\/span>\nclass<\/span> <\/span>EmployeeIterator<\/span> : <\/span>public<\/span> <\/span>PersonIterator<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>EmployeeIterator<\/span>(<\/span>EmployeeList<\/span> <\/span>&<\/span>list<\/span>);<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~EmployeeIterator<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>Employee<\/span> <\/span>*<\/span>GetCurrent<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>Employee<\/span> <\/span>*<\/span>GetNext<\/span>();<\/span><\/span>\n  <\/span>Employee<\/span> <\/span>*<\/span>GetPrevious<\/span>();<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ Other types of Employees<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Secretary<\/span>;<\/span><\/span>\n<\/span>\n\/\/ Manager<\/span><\/span>\nclass<\/span> <\/span>Manager<\/span> : <\/span>public<\/span> <\/span>Employee<\/span><\/span>\n{<\/span><\/span>\n  <\/span>friend<\/span> <\/span>class<\/span> <\/span>Secretary<\/span>;<\/span><\/span>\n<\/span>\npublic:<\/span><\/span>\n  <\/span>Manager<\/span>(<\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>name<\/span>, <\/span>double<\/span> <\/span>salary<\/span>);<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~Manager<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>Secretary<\/span> <\/span>*<\/span>GetSecretary<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>void<\/span> <\/span>SetSecretary<\/span>(<\/span>Secretary<\/span> <\/span>*<\/span>sec<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  \/\/ Don't allow copying or assignment of Managers<\/span><\/span>\n  <\/span>Manager<\/span>(<\/span>const<\/span> <\/span>Manager<\/span> <\/span>&<\/span>);<\/span><\/span>\n  <\/span>Manager<\/span> <\/span>&<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>Manager<\/span> <\/span>&<\/span>);<\/span><\/span>\n<\/span>\n  \/\/ Data<\/span><\/span>\n  Secretary *m_secretary;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n\/\/ Secretary<\/span><\/span>\nclass<\/span> <\/span>Secretary<\/span> : <\/span>public<\/span> <\/span>Employee<\/span><\/span>\n{<\/span><\/span>\n  <\/span>friend<\/span> <\/span>class<\/span> <\/span>Manager<\/span>;<\/span><\/span>\n<\/span>\npublic:<\/span><\/span>\n  <\/span>Secretary<\/span>(<\/span>const<\/span> <\/span>string<\/span> <\/span>&<\/span>name<\/span>, <\/span>double<\/span> <\/span>salary<\/span>);<\/span><\/span>\n  <\/span>virtual<\/span> <\/span>~Secretary<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>Manager<\/span> <\/span>*<\/span>GetManager<\/span>() <\/span>const<\/span>;<\/span><\/span>\n  <\/span>void<\/span> <\/span>SetManager<\/span>(<\/span>Manager<\/span> <\/span>*<\/span>sec<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>Print<\/span>() <\/span>const<\/span>;<\/span><\/span>\n<\/span>\nprivate:<\/span><\/span>\n  \/\/ Don't allow copying or assignment of Secretaries<\/span><\/span>\n  <\/span>Secretary<\/span>(<\/span>const<\/span> <\/span>Secretary<\/span> <\/span>&<\/span>);<\/span><\/span>\n  <\/span>Secretary<\/span> <\/span>&<\/span>operator=<\/span>(<\/span>const<\/span> <\/span>Secretary<\/span> <\/span>&<\/span>);<\/span><\/span>\n<\/span>\n  \/\/ Data<\/span><\/span>\n  Manager *m_manager;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* Employee_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                  \n
                  <\/span>Here’s What to Do:<\/em><\/span><\/h4>\n\n\n\n
                  Now implement these classes (in\u00a0employee.h<\/strong>\u00a0and\u00a0employee.cpp<\/strong>). Creating Employee<\/code><\/strong>, EmployeeList<\/strong><\/code>, and EmployeeIterator<\/strong><\/code> is just like what you did before to construct Person<\/code><\/strong>, PersonList<\/code><\/strong> and PersonIterator<\/code><\/strong>, except that you derive Employee<\/code><\/strong>, et.al. from Person<\/code><\/strong>, et.al, rather than List<\/code><\/strong>, et.al.<\/p>\n\n\n\n
                  Be sure to make each class’ Print()<\/strong> function do something different. Here is a starting point for employee.cpp<\/strong>, to show you what my Employee::Print()<\/strong> looks like, among other things:<\/p>\n\n\n\n
                  <\/path><\/path><\/svg><\/span>
                  \/\/<\/span><\/span>\n\/\/  Employee.cpp<\/span><\/span>\n\/\/  Assignment 5: Linked Lists with Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 11\/1\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span><iomanip><\/span><\/span>\nusing<\/span> <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"employee.h"<\/span><\/span>\n<\/span>\n\/\/ Class Employee<\/span><\/span>\n<\/span>\nEmployee<\/span>::<\/span>Employee<\/span>(<\/span>const<\/span> string &name, <\/span>double<\/span> salary)<\/span><\/span>\n  : <\/span>Person<\/span>(name), <\/span>m_salary<\/span>(salary)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>SetPosition<\/span>(<\/span>"Employee"<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>Employee<\/span>::<\/span>Print<\/span>() <\/span>const<\/span><\/span>\n{<\/span><\/span>\n  cout << <\/span>GetPosition<\/span>().<\/span>c_str<\/span>() << <\/span>": "<\/span> << <\/span>Name<\/span>().<\/span>c_str<\/span>()<\/span><\/span>\n       << <\/span>", salary: "<\/span> << fixed << <\/span>setprecision<\/span>(<\/span>2<\/span>) << m_salary<\/span><\/span>\n       << endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/ You implement the rest...<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
                  Manager::Print()<\/strong> should print out the Employee<\/strong> information (using Employee.Print()<\/strong>), and then print out the secretary name, if any.<\/p>\n\n\n\n
                  Secretary::Print()<\/strong> should print out the Employee<\/strong> information, and then print out the manager’s name, if any.<\/p>\n\n\n\n
                  \n
                  Question<\/strong><\/em>: When you iterate through such a list, do you see the wrong Print() function being called for some items? What do you need to do to make sure that the proper Print()<\/code><\/strong> function is called for each item?<\/p>\n<\/blockquote>\n<\/div>\n<\/div>\n\n\n\n
                  Here’s a main program to test out your new functionality:<\/p>\n\n\n\n
                  \n
                  \n
                  <\/path><\/path><\/svg><\/span>
                  \/\/<\/span><\/span>\n\/\/  TestEmployees.cpp<\/span><\/span>\n\/\/  Assignment 5: Linked Lists with Polymorphism<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 11\/1\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\nusing<\/span> <\/span>namespace<\/span> <\/span>std<\/span>;<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"Employee.h"<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>display<\/span>(<\/span>EmployeeList<\/span> <\/span>&<\/span>list<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  cout << <\/span>"Contents of list:"<\/span> << endl;<\/span><\/span>\n  EmployeeIterator <\/span>iter<\/span>(list);<\/span><\/span>\n  <\/span>for<\/span> (Employee *employee = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>();<\/span><\/span>\n       employee != <\/span>0<\/span>;<\/span><\/span>\n       employee = <\/span>iter<\/span>.<\/span>GetNext<\/span>()<\/span><\/span>\n      )<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>employee<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  cout << <\/span>"-----Dump------"<\/span> << endl;<\/span><\/span>\n  <\/span>list<\/span>.<\/span>Dump<\/span>();<\/span><\/span>\n  cout << <\/span>"---End Dump----"<\/span> << endl;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>ListEmployees<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  EmployeeList list;<\/span><\/span>\n<\/span>\n  Employee  <\/span>FredBloggs<\/span>(<\/span>"Fred Bloggs"<\/span>, <\/span>25000<\/span>);<\/span><\/span>\n  Manager   <\/span>GenghisKhan<\/span>(<\/span>"Genghis Khan"<\/span>, <\/span>105000<\/span>);<\/span><\/span>\n  Secretary <\/span>MargaretThatcher<\/span>(<\/span>"Margaret Thatcher"<\/span>, <\/span>30000<\/span>);<\/span><\/span>\n  Manager   <\/span>BillGates<\/span>(<\/span>"Bill Gates"<\/span>, <\/span>42000000<\/span>);<\/span><\/span>\n  Employee  <\/span>NewtGingrich<\/span>(<\/span>"Newt Gingrich"<\/span>, <\/span>89000<\/span>);<\/span><\/span>\n  Secretary <\/span>Madonna<\/span>(<\/span>"Madonna"<\/span>, <\/span>5000000<\/span>);<\/span><\/span>\n<\/span>\n  Employee *employee[] =<\/span><\/span>\n  {<\/span><\/span>\n    &FredBloggs, &GenghisKhan, &MargaretThatcher,<\/span><\/span>\n    &BillGates, &NewtGingrich, &Madonna<\/span><\/span>\n  };<\/span><\/span>\n<\/span>\n  <\/span>GenghisKhan<\/span>.<\/span>SetSecretary<\/span>(&MargaretThatcher);<\/span><\/span>\n  <\/span>BillGates<\/span>.<\/span>SetSecretary<\/span>(&Madonna);<\/span><\/span>\n<\/span>\n  <\/span>for<\/span> (<\/span>int<\/span> i = <\/span>0<\/span>; i < <\/span>sizeof<\/span>(employee)\/<\/span>sizeof<\/span>(<\/span>employee<\/span>[<\/span>0<\/span>]); i++)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>list<\/span>.<\/span>Append<\/span>(*(<\/span>employee<\/span>[i]));<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  EmployeeIterator <\/span>iter<\/span>(list);<\/span><\/span>\n<\/span>\n  <\/span>for<\/span> (Employee *e = <\/span>iter<\/span>.<\/span>GetCurrent<\/span>(); e != <\/span>0<\/span>; e = <\/span>iter<\/span>.<\/span>GetNext<\/span>())<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>e<\/span>-><\/span>Print<\/span>();<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  \/\/ Display the contents of the list<\/span><\/span>\n  <\/span>display<\/span>(list);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>ListEmployees<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
                  \n
                  Note that this function constructs a list of items that are all Employee<\/strong><\/code>s, or of types derived from Employee<\/code><\/strong>s.<\/p>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
                  Linked Lists With Polymorphism Why More About Linked Lists? So you thought you’d seen all you ever wanted to know about linked lists after the last assignment? Read on… While the previous design worked (at least if you implemented it right…), it had its drawbacks. Let’s list some of them: These shortcomings mostly boil down […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":29,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-34","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/34","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=34"}],"version-history":[{"count":2,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/34\/revisions"}],"predecessor-version":[{"id":1609,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/34\/revisions\/1609"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/29"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=34"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}