Verkettete Liste

cHillb3rT

Also die Klasse Liste hatte ich mir so gedacht:

class Liste
{
  private:
  ListElement *erstes;
  ListElement *letztes;
  int anzahl;
  Liste();
  ertes(0), letztes(0), anzahl(0){}
  virtual ~Liste();
  bool empty() const
  {return (anzahl==0);}
  int size() const
  {return anzahl;}
  void push_back(const string& schluessel, const string& wert);
  void pop_front();
  ListElement* front()
  {return erstes;}
};

Für Anregungen und Kritik bin ich immer offen.....
Ich will ja auch was lernen *g*

Braunstein

Das hier ist doch deine Liste, die du ja evtl. durch eine Standardlösung ersetzen wolltest. Ich meinte eigentlich die Klasse, die du in deiner Liste speichern wolltest ("Person").

cHillb3rT

class TPerson
{
  private:
  char *vorname;
  char *nachname;
  int alter;

  TPerson *p = new TPerson; // müsste die Instanz der Person erzeugen
  public:
  ... // hier müssten ja dann Funktionen und andere Bedingungen noch hin
};

So stell ich mir die Klasse vor, aber ich hab noch keinen Ansatz für eine Klasse, die ich zum Speichern verwende !

Braunstein

Ersetze einfach deine char* durch std::string oder AnsiString und schon brauchst du keinen eigenen Copy-Konstruktor etc. mehr.
Wenn du diese Klasse so wie sie ist verwenden willst, musst du zwingend Konstruktor, Destruktor, Copy-Konstruktor und Zuweisungsoperator erzeugen.
Tu dir einen Gefallen und schmeiss rohe Pointer raus.

cHillb3rT

class TPerson 
{ 
  private: 
  std::string vorname; 
  std::string nachname; 
  int alter; 

  public:
  TPerson();
  TPerson(std::string vorname, std::string nachname, int alter);
  ~TPerson();
  TPerson(const TPerson &Person); 
};

soooo.... wie sieht es denn jetzt aus ?

Braunstein

Wie gesagt, hier kannst du Default-Destruktor und -Konstruktor sowie Copy-Konstruktor weglassen, da für alle Typen in deiner Klasse diese schon existieren und somit automatisch aufgerufen werden.
Bei deinem 2. Konstruktor würde ich eine Initialisierungsliste verwenden. Dann sparst du dir die Implemtierung.
Ansonsten kannst du diese Klasse problemlos in einer Liste verwenden.

std::list<Person> myList;

Wenn deine Daten aus der Datei über streams gelesen und geschrieben werden, könnte man noch die stream-operatoren << und >> dafür überladen um das Ganze etwas zu vereinfachen.

cHillb3rT

Mit der Initialisierungsliste könnte ich es dann so machen:

TPerson::TPerson() : vorname("testvorname") 
{ 
}

oder so:

TPerson::TPerson() : nachname("testnachname") 
{ 
}

oder kann ich gleich alle zusammen initialisieren oder muss ich jeden Wert, den die Person hat, initialisieren ?

Braunstein

Ich dachte eher ans sowas

TPerson(std::string vorname_, std::string nachname_, int alter_) : 
              vorname(vorname_), nachname(namchname_), alter(alter_) {}

Es ist immer besser, wenn die Parameter im Konstruktor andere Bezeichnungen haben als die Membervariablen. Das vermeidet Verwirrung.
Den default-Konstruktor kannst genauso mit einer Initialisierungsliste versehen, ich frag mich bloß warum.

cHillb3rT

class TPerson
{
  private:
  std::string vorname;
  std::string nachname;
  int alter;

  public:
  TPerson();
  TPerson(std::string vorname_, std::string nachname_, int alter_) :
              vorname(vorname_), nachname(namchname_), alter(alter_) {}
  ~TPerson();
};

Also sehe es bisher dann mal so aus.....

Diese Klasse bau ich dann in die Person.h ein, damit ich während der gesamten Laufzeit des Programmes Zugriff darauf habe.

Aber eine andere Frage, die ich mir noch stelle ist: Wie kann ich nun jede Instanz der Klasse abspeichern und später sortiert wieder ausgeben.

Wie kann man das genau machen ?

Braunstein

Eröffne dafür mal bitte einen neuen Thread. Hier im Forum gilt die Regel "Neues Thema - neuer Thread". Ich helfe dir dann gerne weiter.