komische Klassenhierarchie

marcoow

Ich habe die Aufgabe, folgende Klassenhierarchie zu scgreiben:

Klasse LinkedList mit Zeigern auf 2 Elemente Typ Cell lowest und highest
abstrakte Klasse Cell mit Zeigern Typ Cell next und prev
Klasse BaseEl abgeleitet von Cell mit Werten nummer, name
Klasse ListEl abgeleitet von BaseEl mit Werten strasse, stadt etc.

Mein Code dazu sieht so aus:

#include <string>

using namespace std;

class Cell {
  private:
    Cell* next;
    Cell* previous;
  public:
    Cell() {

    }
    virtual ~Cell() {

    }
    virtual string display() const = 0;
};

class LinkedList {
  private:
    Cell* highest;
    Cell* lowest;
  public:
    LinkedList() {
      lowest = 0;
      highest = 0;
    }
    ~LinkedList() {

    }
    void set_lowest(Cell* lowest_cell) {
      lowest = lowest_cell;
    }
    void insert_cell(int customer_number, string customer_name, string customer_street, string customer_postcode, string customer_city, string customer_country) {

    }
    void delete_cell(int customer_number) {

    }
    void retrieve_cell(int customer_number) {

    }
    string display() {

    }
};

class BaseEl : public Cell {
  private:
    string customer_number;
    string customer_name;
    Cell parent_cell;
  public:
    BaseEl(string number, string name) {
      customer_number = number;
      customer_name = name;
    }
    ~BaseEl() {

    }
    string get_number() const {
      return customer_number;
    }
    string get_name() const {
      return customer_name;
    }
    string display() const {
      string return_value;
      return_value = "Nummer:       " + get_number() + "\nName:         " + get_name() + "\n";
      return return_value;
    }
};

class ListEl : public BaseEl {
  private:
    string customer_street;
    string customer_postcode;
    string customer_city;
    string customer_country;
    BaseEl parent_baseel;
  public:
    ListEl(string number, string name, string street, string postcode, string city, string country) : BaseEl(number, name) {
      customer_street = street;
      customer_postcode = postcode;
      customer_city = city;
      customer_country = country;
    }
    ~ListEl() {

    }
    string get_number() const {
      return BaseEl::get_number();
    }
    string get_name() const {
      return BaseEl::get_name();
    }
    string get_street() const {
      return customer_street;
    }
    string get_postcode() const {
      return customer_postcode;
    }
    string get_city() const {
      return customer_city;
    }
    string get_country() const {
      return customer_country;
    }
    string display() const {
      string return_value;
      return_value = "Nummer:       " + get_number() + "\nName:         " + get_name() + "\nStrasse:      " + get_street() + "\nPostleitzahl: " + get_postcode() + "\nStadt:        " + get_city() + "\nLand:         " + get_country() + "\n";
      return return_value;
    }
};

So weit gefällt mir das schon ganz gut, aber ich instantiiere jetzt ein linkedList und würde gerne lowest und highest zuweisen, aber so wie ich das sehe, geht das ja gar nicht, da ich ja von Cell nix instantiieren kann, weil Cell ja abstrakt ist. Außerdem erzeuge ich ja eigentlich immer nur BaseEl's oder ListEl's, im Prinzip müßten die ja als lowest und highest für LinkedList zuweisbar sein. Habe ich was nicht kapiert oder geht das so überhaupt nicht oder wie?

Bitte Hilfe, Marco

[ Dieser Beitrag wurde am 03.05.2003 um 16:34 Uhr von marcoow editiert. ]

nunja du kannst abgeleitete klassen ja über nen basisklassenzeiger verwalten
Cell* = new BaseEl z.b.
das heisst du kannst ganz leicht die beiden Cell pointer zuweisen und dann über die virtuelle methode display die jeweiligen informationen der bageleiteten klassen ausgeben lassen

marcoow

OK, hab's hingekriegt

[ Dieser Beitrag wurde am 03.05.2003 um 17:16 Uhr von marcoow editiert. ]