3. Verkettete Struktur

Verkettete Struktur

  • ?

    Ich bin der Meinung, dass es schon eine gewisse Schwierigkeit darstellt, eine bestimmte Programmiersprache vernünftig zu beherrschen. Alle, die das aus dem Ärmel schütteln, sind bestimmt in der Wirtschaft besser aufgehoben, als für 7€ die Stunde als Hiwi Übungsaufgaben auszuarbeiten.

    0
  • D

    So nachdem der Weihnachtsstress vorbei ist, konnte ich mich nun hiermit weiter beschäftigen.

    Also ich hänge nun bei der Methode Hinzufügen und wollte mal nachfragen, ob das soweit richtig ist.

    #include <iostream>
using namespace std;

class Stack{

private:
        struct Stackstruct{
                int wert;
                Stackstruct *next;
                };
        Stackstruct *stackElement;
public:
        Stack();
        ~Stack();
        int Auslesen();
        void Entfernen();
        void Hinzufuegen(int var);
};

int main()
{

     return 0;
}

// Methoden
Stack::Stack()
{
        stackElement = NULL;
}

Stack::~Stack()
{
        while(stackElement!=0)
        {
                Entfernen();
        }
};

int Stack::Auslesen()
{
        if(stackElement!=0)
        {
                return stackElement->wert;
        }
        else{
                throw"Stack ist leer";
        }
}

void Stack::Entfernen()
{
}

void Stack::Hinzufuegen(int var)
{

        if(stackElement==0)
        {
        Stackstruct * newElement = new Stackstruct;
        stackElement->wert = var;
        stackElement->next = NULL;
        }
        else
        {
        Stackstruct *newElement = new Stackstruct;
        stackElement = newElement;
        stackElement->wert = var;
        stackElement = stackElement->next;
        }
}
    0
  • A

    Darky1985 schrieb:

    Also ich hänge nun bei der Methode Hinzufügen und wollte mal nachfragen, ob das soweit richtig ist.

    Kurz gesagt: Nein.
    Wenn du schon die vorgeschlagene Variante mit den Konstruktoren ignorierst, musst du auch aufpassen was du mit den alten Werten machst (Zudem muss Entfernen auch die Elemente löschen).

    void Stack::Hinzufuegen(int var)
{
    if(stackElement==0)
    {
        // Hier musst du stackElement anlegen, und setzen
    }
    else
    {
        // Hier musst du stackElement "merken", und ein neues Element
        // anlegen. Dieses bekommt das bisherige stackElement als Next.
        // anschließend muss das neue Element stackElement ersetzen.
    }
}

    cu André
    P.S: Wie wäre es wenn du meinen alten Text wirklich einmal durchliest und versuchst zu verstehen, bevor du schlecht übernimmst und noch schlechter implementierst?

    0
  • D

    Anscheind muss ich mir das nochmal genauer durchlesen, da ich nicht weiß was du gerade meinst. Hab doch alles übernommen bis auf

    StackDatensatz(
                int wert,
                StackDatensatz* next)
            :   wert(wert), // Initialisierungsliste ist der Zuweisung vorzuziehen
                next(next)
            {
            }

    oder ist dies hier auch gemeint?

    Was macht dein Konstruktor eigendlich anders als meiner? Habe diese Deklaration noch nicht gesehen.

    0
  • A

    Darky1985 schrieb:

    Anscheind muss ich mir das nochmal genauer durchlesen, da ich nicht weiß was du gerade meinst. Hab doch alles übernommen bis auf

    Du hast beileibe nicht alles übernommen, geschweige den gelesen.
    Noch dazu eine weitere Bitte: Rück deinen Code sinnvoll ein, der ist so recht schwierig zu überschauen.

    Darky1985 schrieb:

    Was macht dein Konstruktor eigendlich anders als meiner? Habe diese Deklaration noch nicht gesehen.

    Zum einen hast du gar keinen Konstruktor, außer vielleicht den vom Compiler generierten, zum anderen habe ich dies alles in meinem Text beschrieben. Du hast diesen Text meiner Meinung aber noch nicht einmal gelesen, geschweige den versucht ihn zu verstehen (Den dann würden deine Fragen mit Sicherheit konkreter sein).

    Leg dir bitte ein sinnvolles C++ Buch zu (z.B. C++ Primer), und halte dich an die Lernreihenfolge, wenn du schon wirklich ausführliche Beschreibungen nicht einmal ansatzweise liest.

    cu André

    0
  • D
     

    Stack::Stack()
{
        stackElement = NULL;
}

    Das ist doch der Konstruktor und Stack::~Stack der Destruktor..
    Deinen Text habe ich schon mehrmals gelesen aber so wie es aussieht ohne Erfolg. Nunja..

    0
  • U

    hmm... wahrscheinlich hat asc den übersehen oder sich komisch ausgedrückt - ich jedenfalls sehe deinen CTor ^^

    btw nennt sich

    Stack::Stack() 
:   stackElement(NULL) //<--- das hier
{ 
}

    Initialisierungsliste... und man sollte sie auch nutzen ^^

    bb

    0
  • A

    unskilled schrieb:

    hmm... wahrscheinlich hat asc den übersehen oder sich komisch ausgedrückt - ich jedenfalls sehe deinen CTor ^^

    Aber nicht den von StackDatensatz...

    0
  • U

    asc schrieb:

    unskilled schrieb:

    hmm... wahrscheinlich hat asc den übersehen oder sich komisch ausgedrückt - ich jedenfalls sehe deinen CTor ^^

    Aber nicht den von StackDatensatz...

    OK - den hab ich natürlich auch noch nicht entdecken können ^^

    bb

    0
  • R

    Ich hab mal meinen Stringstack ausgegraben:

    /*
  Die Implementierung eines String-Stack nach dem LIFO-Prinzip.
*/

#include <iostream>
#include <string>
using namespace std;

class StringStack {
  private:
    struct Element {
      string s;
      Element *vorgaenger;
    };
    Element *aktuelles;
    int zaehler;

  public:
    StringStack();
    ~StringStack();
    bool leer();
    void push(string s);
    string pop();
};

StringStack::StringStack() {
  aktuelles = NULL;
  zaehler = 0;
}

StringStack::~StringStack() {
  Element *temp = NULL;
  while(aktuelles != NULL) {
    temp = aktuelles;
    aktuelles = aktuelles->vorgaenger;
    delete temp;
  }
  temp = NULL;
}

bool StringStack::leer() {
  return zaehler == 0;
}

void StringStack::push(string s) {
  Element *neues = new Element;
  neues->s = s;
  neues->vorgaenger = NULL;
  if(aktuelles != NULL) {
    neues->vorgaenger = aktuelles;
  }
  aktuelles = neues;
  ++zaehler;
}

string StringStack::pop() {
  if(zaehler > 1) {
    string temp = aktuelles->s;
    aktuelles = aktuelles->vorgaenger;
    --zaehler;
    return temp;
  }
  else if(zaehler == 1) {
    string temp = aktuelles->s;
    aktuelles = NULL;
    --zaehler;
    return temp;
  }
  else {
    return "Fehler: pop() bei leerem Stack.";
  }
}

int main() {
  StringStack *stack = new StringStack();
  stack->push("Test");
  stack->push("C");
  stack->push("C++");
  while(!stack->leer()) {
    cout << stack->pop() << endl;
  }
  delete stack;
  stack = NULL;
  return 0;
}

    Falls Fragen auftreten, einfach stellen 😉

    0
  • ?

    Darky1985 schrieb:

    irgendwie dachte ich, dass verkettete Listen dynamisch sind. Wollte ja mehrere Daten eingeben können aber das Funktioniert ja nicht.. NOCH nicht. Was müsst ich am Code denn ändern damit es Funktioniert?

    Über google auf diese Seite gestossen, ich glaube nicht das es beabsichtigt ist die Bearbeitungs-Seite über google zu finden http://www.google.de/url?sa=t&source=web&cd=7&ved=0CEUQFjAG&url=http%3A%2F%2Fwww.c-plusplus.net%2Fforum%2Fquote1630730&rct=j&q=verkettete%20liste%20aus%20dem%20%C3%A4rmel%20sch%C3%BCtteln&ei=mynSTeaZN4jSsgbz-ISnCQ&usg=AFQjCNFbYDABu3nHx3zb8xKtxoayu8Xa6Q&cad=rja

    0
  • N

    Google-Sucher schrieb:

    ich glaube nicht das es beabsichtigt ist die Bearbeitungs-Seite über google zu finden

    Du hast nicht die Bearbeitungsseite sondern die Antwortseite gefunden. Und das Problem ist seit einiger Zeit behoben, aber das betrifft natuerlich keine Threads, die von Google bereits vorher indiziert wurden.

    0
Anmelden zum Antworten