The Basic List Class: A First Design:

We consider a variety of ways to implement a basic ADT list structure as a class. The list consists of objects of type CELL hooked together via pointers. So we can do this:

• Build a CELL class
• Build a LIST class using CELL objects.

Here are details: First, a skeleton outline of the class headers that is heavily annotated:

The CELL Class:

We start with the parent class or core class. As usual, we set the type of the object with the use of a defined TYPE macro. Note

• the use of a protected field entry. Such an agent or element will be accesible to all derived children of the parent class.
• the use of the new key word virtual as part of the prototype. This indicates that this agent can be replaced by the agent with the identical prototype in any of the parent's children.
• the use of the phrase const = 0 after the prototype of ostream print(ostream& out). The const indicates that the left hand argument is considered a const argument-this implies that the right hand argument can't be modified. The = 0 indicates that this agent is pure virtual and there is no code for this agent supplied in the parent class. Any class with pure virtual agents can't be instantiated.

#define TYPE char

class CHAR_CELL_CORE{
    friend class CHAR_LIST_CORE;
    friend ostream& operator<<(ostream&,const CHAR_CELL_CORE&);
    friend ostream& operator<<(ostream&,const CHAR_CELL_CORE*);
  public:
    void load_element(TYPE x){element = x;};
  protected:
    virtual ostream& print(ostream& out) const = 0;
    TYPE element;
  };

The derivation chain shown here is

• Parent: CHAR_CELL_CORE
  • Child: CHAR_SL_CELL
  • SubChild: CHAR_DL_CELL

and it is by no means the best way to do this: We immediately notice consequences of this design:

• The char *name field is added at the CHAR_SL_CELL child and then inherited by the CHAR_DL_CELL subchild. Why not just put the char *name field in the parent class?
• Each child implements a print agent. Since all we wish to print is TYPE element, why not put the print in the parent and inherit it down the line?
• Why is the print agent protected?
• Why isn't there a version of an input agent for the class, say grab?
• The CHAR_DL_CELL subchild has field elements
  • TYPE element from parent
  • char *name from CHAR_SL_CELL
  • CHAR_SL_CELL *next from CHAR_SL_CELL
  • CHAR_DL_CELL *previous from CHAR_SL_CELL
  Is this mismatch of pointer types for next and previous a problem?

class CHAR_SL_CELL : public CHAR_CELL_CORE{
    friend class CHAR_SLLIST;
  public:
    CHAR_SL_CELL(char *name_in);
    ~CHAR_SL_CELL();
    ...agents...here
  protected:
    char * name;
    CHAR_SL_CELL *next;
    ostream& print(ostream& out) const;
  };

class CHAR_DL_CELL : public CHAR_SL_CELL{
    friend class CHAR_DLList;
  public:
    CHAR_DL_CELL(char *name_in);
    ~CHAR_DL_CELL();
    ...agents here...
  protected:
    CHAR_DL_CELL *previous;
    ostream& print(ostream& out) const;
  };

The LIST Class:

The LIST class is then built using CELL objects:

class CHAR_LIST_CORE{
    friend class CHAR_CELL_CORE;
    friend istream& operator>>(istream&,CHAR_LIST_CORE&);
    friend istream& operator>>(istream&,CHAR_LIST_CORE*);
    friend ostream& operator<<(ostream&,const CHAR_LIST_CORE&);
    friend ostream& operator<<(ostream&,const CHAR_LIST_CORE*);
  public:
    ...agents...
    virtual ofstream& getOutputFile() = 0;
    virtual ifstream& getInputFile() = 0; 
  protected:
    virtual istream& grab(istream& in) = 0;
    virtual ostream& print(ostream& out) const = 0;
  };

class CHAR_SLLIST : public CHAR_LIST_CORE{
    friend class CHAR_SL_CELL;
  public:
    CHAR_SLLIST(char *name_in);
    CHAR_SLLIST(CHAR_SLLIST&);
    ~CHAR_SLLIST();
    CHAR_SLLIST& operator=(const CHAR_SLLIST&);
    ...agents...
    ofstream& getOutputFile() {return(outputFile);};
    ifstream& getInputFile() {return(inputFile);};
  protected:
    char *name;
    CHAR_SL_CELL *head;
    ...agents...
    istream& grab(istream& in);
    ostream& print(ostream& out) const;
    ifstream inputFile;
    ofstream outputFile;
  };
#endif

• Do we need stream objects in CHAR_SLLIST? Why not put them in the parent if we need them?
• How would we do a CHAR_DLLIST class?
• Why are the grab and print agents protected?