Probleme mit dynamischer Struktur

_freeze_

Hey @all,

ich habe vor Personen und spezifische Daten aufzunehmen, und diese anschließend in einer Datei zu speichern.

Bisher habe ich es wie folgt gemacht:

struct PersonDat {
  char name[80];
.
.
.
};

struct SpecDat {
  char web_link[80];
  char mail_adr[30];
.
.
.
};

struct Data {
  struct PersonDat person;
  struct SpecDat specific;
};

Mein Problem was ich jetzt habe ist, das jede Person mehrere Email-Adressen oder Webseiten haben kann, die er eintragen möchte. Wie kann ich das am besten lösen, damit ich keine probleme mit dem Einlesen der Daten bekomme, und ich es schön/effektiv im Programm verwalten kann?

Vielen dank im Voraus

Lg _freeze_

akari

Hallo

statt char-Array lieber AnsiString verwenden.
http://bcb-tutorial.c-plusplus.net/Ansi/index.html

bis bald
akari

BigNeal

du kannst für die E-mail adresse zB ein Array brauchen.

struct SpecDat 
{
  char web_link[10][80];
  char mail_adr[10][30];
}

wobei ich dir aber eher zu AnsiString raten würde, als char[](ist ansichtssache)
so ersparst du dir aber probleme mit der länge des Strings

struct SpecDat 
{
  AnsiString web_link[10];
  AnsiString mail_adr[10];
}

und wenn du die länge des Arrays dynamisch verwalten möchtest, währe DynamicArray ne möglichkeit

struct SpecDat 
{
   DynamicArray<AnsiString> web_link;
   DynamicArray<AnsiString> mail_adr;
}

oder einfach ne vorgefertigte Klasse verwenden. zB TListBox

struct SpecDat 
{
  TListBox *web_link;
  TListBox *mail_adr;
}

läst sich dan auch gut optisch darstellen.

_freeze_

Danke für die schnellen Antworten, jedoch kann man das auch irgendwie mit Ansi C++ lösen? Den wenn ich std::string verwende, dann ändert sich ja bei jedem Eintrag die Länge des strings...und somit bekomme ich ja dann Probleme beim Einlesen.

Die Informationen würde ich da wie folgt in die Dateien schreiben

file.write(reinterpret_cast<char*>(&Data), sizeof(Data));

Lg _freeze_

Braunstein

Bei std::string mußt du halt vorher die Länge des Strings mit abspeichern. Du kannst dir für sowas auch einfach jeweils read/write Methoden schreiben, die das für dich übernehmen oder den String in eine extra Klasse packen die das für dich macht (mach ich so). Statt statischer Arrays oder DynamicArray sollte man dann auch lieber std::vector verwenden. Wobei man auch hier die Länge vorher mit speichern muß. Wenn man das alles in deine Klassen integriert (read/write-Methoden) gibt es keine Probleme mehr.

_freeze_

Ja, sowas hatte ich mir schon gedacht, nur wie sollte dann so eine Klasse aussehen? Ich meine da muss ich ja dann für jedes Element eine Set/Get Methode schreiben zum lesen und Schreiben in die Form. Zusätzlich müsste ich dann ja quasi Tags mit in die Datei schreiben, damit ich weiß welche Information wohin gehört...oder denke ich da etwas zu kompliziert?

Kannst Du mir ev. zeigen wie Du das meinst mit der Klasse?

Lg _freeze_

Braunstein

Ich kenn jetzt deine Klassenstruktur zu wenig um das konkret zu sagen. Ich würde für jede Einzelklasse read/write-Methoden schreiben (die bloß eine Referenz auf den Stream übernehmen). Die übergeordneten Klassen müssen dann nur noch diese Methoden innerhalb ihrer eigenen read/write Methoden aufrufen. Etwa so:

struct string_adapter
{
   std:: string str;
   void write(std::ostream &out)
   {
      int length = str.length();
      out.write((char*)(&length),sizeof(length));
      out.write(str.c_str(), size);
   }
   int  read(std::istream &in)
   {
      int length;
      int size = in.read((char*)(&length),sizeof(length));
      char* buffer = new char[length+1];
      size = in.read(buffer,length);
      buffer[length] = '\0';
      str = buffer;
      delete[] buffer;  // edit
   }
};

struct string_vect
{
   std::vector<string_adapter> strvect;
   void write(std::ostream &out)
   {
      int length = strvect.size();
      out.write((char*)(&length),sizeof(length));
      for( unsigned int i=0; i<length; ++i)
         strvect.write(out);
   }
// und so weiter
}

_freeze_

Ähm...jetzt haben wir glaube ich aneinander vorbeigeredet.
Hatte mich nicht klar genug geäußert.

Und zwar hattest Du gesagt, das ich die Weblinks/Emailadressen usw. in Vectoren pushen soll, soviele wie der Benutzer halt benötigt...ok ist verständlich.

das ganze würde dann ja so aussehen:

struct Weblinks {
  std::string link;
};

struct PersonDat {
  std::string name;
  std::vector<Weblinks> vWebLink;
};

und als Write Methode nehme ich dann nur den namen, schreibe die länge, schreibe den namen....danach schreibe ich die Anzahl der Links(im Vector) und schreibe für jeden Link die Länge inkl. text in die datei...ist das so richtig, oder geht das auch einfacher?

Lg _freeze_

Hallo _freeze,

ich weiß ja nicht wie das ganze Projekt aussieht, aber das scheint mir doch eher ein Fall für ne Datenbank. Eine Tabelle für die Leute und eine verlinkte Tabelle für Mailadressen, dann kann jeder soviel Mailadressen haben wie er will. Die ganze Soße sortiert in ein File copieren möchte auch gehen. Mit BCB eine einfache Lösung. Und die Wartung der Daten geht auch einfacher.

manchmal hilft ein neuer Ansatz...

Gruß rudiS