Ich möchte Daten in einer mit new erzeugten Struktur speichern.

// Beginn meiner Funktion
Struktur *neuesElement = new Struktur;
// Struktur wird mit Daten befüllt
return neuesElement;
// Ende meiner Funktion

Da dies in einer Funktion geschieht will ich den Zeiger zurückgeben und in einer Liste Speichern (Liste meiner Elemente).

Diese Liste würde ich wie folgt erstellen wollen (geht das???):

Struktur *adress_Liste[2]; //Hier Liste für zwei Element-Adressen
adress_Liste[0] = funktion_zum_anlegen_meiner_Elemente();
adress_Liste[1] = funktion_zum_anlegen_meiner_Elemente();

Da ich aber flexibel mit der Anzahl meiner Elemente sein will habe ich mir folgendes überlegt: Ich lege eine Variable für die Elementenanzahl an und einen Zeiger der auf die aktuelle Liste zeigt. Sobald ein neues Element hinzukommen soll wird eine neue Liste erzeugt in der die Anzahl der aktuellen Elemente plus 1 aufnehmen kann. Ich kopiere alle Adressen aus der aktuellen Liste in die neue Liste, füge dann die Adresse des neuen Element hinten dran. Dann wird die aktuelle Liste gelöscht und die Adresse der neuen Liste in den Listenzeiger gespeichert.

Listenzeiger  --> [Adresse: AdressListe aktuell  ]
                  [ 0 (Adresse von Struktur 1)   ] --> [Struktur1]
                  [ 1 (Adresse von Struktur 2)   ] --> [Struktur2]
                  [ 2 (Adresse von Struktur 3)   ] --> [Struktur3]

Wird nun eine Strukur4 erzeugt, wird eine neue Adressliste erstellt und mit den alten Adressen, so wie die Adresse des neuen Element, befüllt.

Listenzeiger  --> [Adresse: AdressListe aktuell  ]
                  [ 0 (Adresse von Struktur 1)   ] --> [Struktur1]
                  [ 1 (Adresse von Struktur 2)   ] --> [Struktur2]
                  [ 2 (Adresse von Struktur 3)   ] --> [Struktur3]

                  [Adresse: AdressListe neu      ]
                  [ 0 (Adresse von Struktur 1)   ] --> [Struktur1]
                  [ 1 (Adresse von Struktur 2)   ] --> [Struktur2]
                  [ 2 (Adresse von Struktur 3)   ] --> [Struktur3]
                  [ 3 (Adresse von Struktur 4)   ] --> [Struktur4]

Danach die alte Liste löschen und den Listenzeiger auf die neue Liste setzen:

Listenzeiger  --> [Adresse: AdressListe new(jetzt aktuell)  ]
                  [ 0 (Adresse von Struktur 1)              ] --> [Struktur1]
                  [ 1 (Adresse von Struktur 2)              ] --> [Struktur2]
                  [ 2 (Adresse von Struktur 3)              ] --> [Struktur3]
                  [ 3 (Adresse von Struktur 4)              ] --> [Struktur4]

Mein Ansatz wäre folgender:

class Speicher
{
// Member-Funktionen:
  public:
    Speicher();
    Element_add();
    Element_sub();

// Member-Variablen:
  private:
    int anzMember;
    struct Struktur{
      char text1[100];
      char text2[100];
      // Hier wird warschl. später noch mehr hinzukommen.
    };
    Member **ptr_vokabel_Liste;
};
Speicher::Speicher()
{
  anzVokabeln = 0;          // Anzahl der Vokabeln: initalisieren
  Struktur *adress_Liste[1];
  adress_Liste[0] = 0;      // 
  ptr_adressen_Liste = new (???) //<-- was muss hier her? Eigentlich ja der Typ also Struktur[] ???
};

Bin ehrlich gesagt noch Anfänger, das Programm das ich erstelle soll mir helfen, mich in C++ rein zu denken. Ich habe mir vorgenommen ein Programm zur Abfrage von Vokabeln zu erstellen. Stehe ganz am Anfang, aber schon vor meinem ersten Problem: Wo und wie speichere ich die zueinander gehörenden Vokabeln ab.

Habe mir vorgenommen das Programm ganz einfach als Konsolen-Anwendung zu schreiben. Und sobald es das absolute Minimum an Funktionen hat und sicher läuft, werde ich mir mir ein paar weitere Funktionen ausdenken und die hinzufügen... usw.

Und das es in dieser Standardbibliothek Container gibt?
http://www.cplusplus.com/reference/stl/

Und das es dort eine Map gibt, wo man Werte zu Schlüsseln speichern kann?
http://www.cplusplus.com/reference/stl/map/

Womit lernst du C++?

Grüssli

mtepe schrieb:

Mein Ansatz wäre folgender:

class Speicher
{
//....
// Member-Variablen:
  private:
    int anzMember;
    struct Struktur{
      //....
    };
    Member **ptr_vokabel_Liste;
};
Speicher::Speicher()
{

  anzVokabeln = 0;          // Anzahl der Vokabeln: initalisieren
  Struktur *adress_Liste[1];
  adress_Liste[0] = 0;      // 
  ptr_adressen_Liste = new (???) //<-- was muss hier her? Eigentlich ja der Typ also Struktur[] ???
};

Also das ganze hat ein paar Lücken. die Anzahld er enthaltenen Vokabeln ist schonmal so richtig. die 2 Zeilen danach ergeben erstmal so keinen Sinn. und die Zeile darunter muß new Zeiger sein.

korrekt würde das ganze so aussehen:

Speicher::Speicher()
{

  anzVokabeln = 0;          // Anzahl der Vokabeln: initalisieren
  ptr_adressen_Liste = new Structur*[x]//du erstellst auf einen Zeiger Zeiger eine Liste aus Zeigern, x ist die gewünschte Anzahl
};

Damit kannst du jetzt folgendes machen:

ptr_adressen_Liste[x]=new Structur;

New Structur kann dabei auch eine Funtkion sein die einen zeiegr auf Structur zurückgibt. Wichtig dabei, unbedingt beachten, wenn du delete[] auf ptr_adressen_Liste machst wird nur die Liste gelöscht nicht der Inhalt, dh wenn du die Liste erweiterst brauchst du nur die zeiger in die neue Liste zuzuweisen und die Alte zu löschen, aber wenn du die liste nicht mehr brauchst mußt du vor dem Löschen der Liste ein delete auf jedes Element der liste machen in dem ein Objekt steckt sonst gibts Speicherlecks vom feinsten.

Ich würde dir wenn du es so machen willst raten die Liste imemr gleich etwas weiter zu erweitern, sonst müsstest du sie für alles was du hinzufügst jedesmal ne erweietrung durchführen. Außerdem solltest du dann ungenutzte Zeiger auf NULL setzen.