4. Verkettete Liste

Verkettete Liste

  • A

    Hallo

    dafür kansst du sowohl Arrays (vector) als auch Listen (list) nehmen, eventuell sogar map.
    Wenn du wahlfreien Zugriff auf die Datensätze haben willst, nimm vector.
    Wenn du viel durch die Datesätze iterieren und viel innerhalb bestehender Datensätze einfügen willst, nimm list.
    Wenn du gleich einen Index über z.B. den Namen der Personen haben willst, nimm map.

    bis bald
    akari

    0
  • B

    Für kleiner Datenmengen ist TStringList hier sicherlich ausreichend. Bei sehr großen Datenmengen dann evtl std::liststd::string. Wobei man hier überlegen sollte ob es wirklich notwendig ist alle Daten immer im Speicher zu halten.
    Dann bietet sich evtl. auch eine Datenbank an.

    0
  • C

    Dann hab ich mal eine Frage... 😉

    Ich hab dann meine Klasse "Person" und in der Klasse werden dann immer wieder Instanzen gemacht für jede neue Person, die ich auslese und dann müsste ich doch innerhalb der Klasse dann immer wieder neue Stringlisten machen oder kann ich alles in eine einzige reinschreiben ?

    und wie sieht das dann so BTW aus ?

    0
  • B

    Du solltest wohl besser eine Liste auf deine Klasse "Person" machen und die dann verwalten.

    0
  • C

    aha.... wie würde das denn dann aussehen ?

    0
  • B

    Zeig doch mal die Deklaration deiner Klasse.

    0
  • C

    Ich hab noch nicht so genau eine Ahnung, wie ich das bauen werde...

    Ich weiß nur, dass ich wegen der dynamischen Speicherung Wert auf den Copy-Ctor legen muss.

    Ich hab ja erst angefangen mit C++ und arbeite mich erst hier rein. Der Chef fängt halt immer gleich mit guten Aufgaben an *g*

    0
  • B

    Wenn du Containerklassen verwendest benötigt deine Klasse default Konstruktor, Copy-Konstruktor und Zuweisungsoperator. Wenn du aber in deiner Klasse aber keinen Speicher allozieren musst, reichen in der Regel auch die defaultmässig erzeugten Funktionen. Deswegen sagte ich ja, du sollst mir mal deine Deklaration zeigen.

    0
  • C

    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*

    0
  • B

    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").

    0
  • C
     

    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 ! 😕

    0
  • B

    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.

    0
  • C
     

    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 ?

    0
  • B

    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.

    0
  • C

    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 ?

    0
  • B

    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.

    0
  • C
     

    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 ?

    0
  • B

    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.

    0
Anmelden zum Antworten