Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (WinAPI, Konsole) » createStack

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] > 2 < [ 3 ]
010
19.10.2008, 22:29 Uhr
ao

(Operator)


Ah ja. Aber das heißt, der content-Pointer muss auf n char-Elemente zeigen. n Stack-Elemente zu allozieren ist falsch.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
011
20.10.2008, 18:26 Uhr
KFC Embryo
Ein Huhn


Jetzt bin ich komplett verwirrt.

Also folgender maßen sieht mein Programm jetzt aus:


Code:

#include <iostream>
using namespace std;

#include "stack.h"


int main(){
    
    Stack *s;
    s=createStack(3);
    push(s, 'a');
    push(s, 'b');
    push(s, 'c');
    push(s, 'd');

    while (! isEmpty(s))
            cout << pop(s) << endl;
    pop(s);
    destroyStack(s);
    cin.ignore();
    return 0;
}

Stack* createStack(unsigned int n){
    
    Stack *s;

    s = (Stack*) calloc(n, sizeof(Stack));
    
    return s;
}

void push(Stack *s, char c){
    
    
    if(s->top == s->depth-1)
        return;

    s->content++;
    s->*content=c;
    s->top++;
}




Der Datentyp "Stack" ist in der der Header Datei "Stack.h" deklariert:


Code:
struct Stack{
    unsigned int depth;
    char         *content;
    unsigned int top;
};



Wenn ich es so mache bekomme ich die Fehlermeldung:


Code:
error C2065: 'content': nichtdeklarierter Bezeichner



Wie könnte den die Version mit new aussehen?
Und warum bekomme ich die Fehlermeldung das der Bezeichner nicht deklariert ist?

gruß
--
An nescis, mi fili, quantilla prudentia mundus regatur?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
012
20.10.2008, 18:44 Uhr
0xdeadbeef
Gott
(Operator)



C++:
    s->*content=c;


ist falsch und muss

C++:
    *s->content=c;


heißen.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
013
20.10.2008, 19:16 Uhr
KFC Embryo
Ein Huhn


Stimmt macht Sinn es ist ja ein Zeiger auf "s.content" und nicht auf content, davon abgesehen das es die "variable" ja wirklich nicht gibt, oder?

Ok sowit bin ich jetzt fertig es kommen zumindestens keine Compilier Fehler mehr aber ein Laufzeitfehler macht mir jetzt zu schaffen:


Code:
#include <iostream>
using namespace std;

#include "stack.h"


int main(){
    
    Stack *s;
    s=createStack(3);
    push(s, 'a');
    push(s, 'b');
    push(s, 'c');
    push(s, 'd');

    while (! isEmpty(s))
            cout << pop(s) << endl;
    pop(s);
    destroyStack(s);
    cin.ignore();
    return 0;
}

Stack* createStack(unsigned int n){
    
    Stack *s;

    s = (Stack*) calloc(n, sizeof(Stack));
    
    return s;
}

void push(Stack *s, char c){
    
    if(s->top == s->depth-1)
        return;

    s->content++;
    *s->content=c;
    s->top++;
}

char pop(Stack *s){

    return (*s->content);
    
}

int isEmpty(Stack *s){

    if(s->top>=0){
    s->top = s->top-1;
    }
    return (s->top);
}

void destroyStack(Stack *s){
    
    free(s);
}



--
An nescis, mi fili, quantilla prudentia mundus regatur?

Dieser Post wurde am 20.10.2008 um 19:38 Uhr von KFC Embryo editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
014
20.10.2008, 20:48 Uhr
ao

(Operator)


createStack ist falsch. Du erzeugst ein Array aus drei Strukturen vom Typ Stack.

Du willst so ungefähr folgendes:

C++:
// ohne Test hingekritzelt, daher keine Gewähr!
Stack * createStack (unsigned int n)
{
    Stack * s = malloc (sizeof (Stack *));
    s->content = calloc (n, sizeof (char));
    s->depth = n;
    s->top = 0;
}


"Ungefähr" deshalb, weil ich nicht hundertprozentig verstanden habe, was genau du in top verwaltest.

Und pop muss genau das Inverse von push machen, also auch content und top modifizieren.

Dieser Post wurde am 20.10.2008 um 20:52 Uhr von ao editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
015
21.10.2008, 12:34 Uhr
Lensflare




Zitat von KFC Embryo:
Wie könnte den die Version mit new aussehen?


C++:
Stack * createStack (unsigned int n)
{
    Stack * s = new Stack;
    s->content = new char[n];
    //hier noch das char array mit 0 füllen wenn man möchte
    s->depth = n;
    s->top = 0;
}


Wenn schon mit new, dann wäre es auch besser den Stack als Klasse zu implementieren, im Konstruktor aufzubauen und push und pop als Methoden der Klasse zu machen.
Also:

C++:
class Stack
{
private:
  unsigned int depth;
  char *content;
  unsigned int top;

public:
  Stack(int n) {
    content = new char[n];
    depth = n;
    top = 0;
  }

  bool push(char c) //Gibt zurück: true bei Erfolg, false wenn Stack voll
  {
    if(top == depth-1)
        return false;

    content++;
    *content=c;
    top++;

    return true;
  }

  char pop()
  {
    //...
  }
};


Keine Garantie auf Erfolg weil ich gerade keinen C++ Kompiler zur Hand habe
--
Wenn das Gehirn so einfach wäre, dass wir es verstehen könnten, wären wir so einfach, dass wir es nicht verstehen könnten.
(Emerson Pugh Trost)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
016
21.10.2008, 14:41 Uhr
ao

(Operator)


OK, also nach 10 Antworten, in denen wir genau darüber gerätselt haben, wissen wir nun endlich, dass C++ eingesetzt wird und nicht C, #include <iostream> hats verraten.

Also vergiss struct und malloc und nimm class und new. Und verrate uns sowas in Zukunft bitte gleich am Anfang.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
017
22.10.2008, 19:24 Uhr
KFC Embryo
Ein Huhn


Hallo,

ja Entschuldigung war keine Absicht ging etwas unter:


Code:

#include <iostream>
using namespace std;

#include "stack.h"


int main(){
    
    Stack *s;

    s=createStack(3);
    push(s, 'a');
    push(s, 'b');
    push(s, 'c');
    push(s, 'd');
    
    cout << pop(s) << endl;
    destroyStack(s);
    cin.ignore();
    return 0;
}

Stack* createStack(unsigned int n){
    
    Stack *s;

    s = (Stack*) malloc(sizeof(Stack));
    s->content = (char*) malloc(n*sizeof(char));
    return s;
}

void push(Stack *s, char c){
    
    if(s->depth <= s->top){
        *s->content=c;
         s->top++;
        cout << "Hinzugefuegt" << endl;
    }
    else{
        cout << "Stack ist voll!" << endl;
}
}

char pop(Stack *s){

    if(s->top <= s->depth){
         s->top--;
         *s->content;
         cout << *s->content << endl;
    }
    else{
        cout << "Stack ist leer" << endl;
}
    return 0;
}


void destroyStack(Stack *s){
    
    free(s);
}




Ich habe immer noch Probleme.
Folgendes, wenn ich eine Code wie den obigen jetzt habe in Compiliere dann bekomme ich als Ausgabe:


Code:
Hinzugefügt!
Hinzugefügt!
Hinzugefügt!
Hinzugefügt!
Stack ist leer....



Was ich aber haben möchte ist:


Code:
Hinzugefügt
Hinzugefügt
Hinzugefügt
Stack ist voll!
a
b
c
Stack ist leer!



Ich habe riesen Probleme damit zu verstehen wie man Prüfmechanismen mittels depth und top erstellen kann also prüfen ob der Stack voll oder leer ist.
Wäre echt genial wenn mir da einer von euch weiter helfen könnte damit ich dieses Programm zum laufen bringe.
Seht mir bitte die Syntaxfehler nach, ich versuche gerade den Spagat zwischen C und C++.

Danke.

Gruß
--
An nescis, mi fili, quantilla prudentia mundus regatur?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
018
22.10.2008, 20:30 Uhr
ao

(Operator)


Da fehlt noch die ganze Verwaltung.

depth und top müssen in createStack initialisiert werden.

In push muss content inkrementiert werden (sonst pushst du immer auf dasselbe Element).

In pop muss content wieder dekrementiert werden. Außerdem sollte pop das gepoppte Element nicht auf den Bildschirm schreiben, sondern zurückgeben (per Referenzparameter) und über einen bool-schen Returnwert anzeigen, ob der Stack leer war oder nicht.

Und in destroyStack muss zuerst der ganze Stack leergepoppt werden (damit content wieder auf den Anfangswert zeigt. Danach muss content gefreet werden und danach erst s selber.

Was heißt, du versuchst den Spagat zwischen C und C++?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
019
22.10.2008, 21:00 Uhr
Lensflare



So, ich hab das ein wenig umgebaut.
Die Kommentare mit dem Ausrufezeichen (// !) markieren die veränderten Stellen.


C++:
#include <iostream>
using namespace std;

//#include "stack.h"

struct Stack {
    unsigned int depth; // maximale Tiefe (Anzahl der Elemente die in den Stack passen)
    char         *content;
    unsigned int top; // aktuelle Tiefe (Position des tiefsten Elements im Stack).
};

Stack* createStack(unsigned int n){

    Stack *s;

    s = (Stack*) malloc(sizeof(Stack));
    s->content = (char*) malloc(n*sizeof(char));
    s->depth = n; // ! maximale Tiefe ist n
    s->top = 0; // ! aktelle Tiefe ist 0, da noch noch kein Element im Stack ist
    s->content--;
    return s;
}

void push(Stack *s, char c){

    if(s->top < s->depth){ // ! wenn aktuelle Tiefe kleiner als maximale Tiefe...
         s->content++; // !
        *s->content=c;
         s->top++;
        cout << "Hinzugefuegt" << endl;
    }
    else{
        cout << "Stack ist voll!" << endl;
    }
}

char pop(Stack *s){

    if(s->top >= 1){ // !
        char c = *s->content; //Element lesen...
        *s->content = 0; //...und "löschen"
         s->top--;
         s->content--; // !
         cout << "Herausgeholt" << endl;
         return c;
    }
    else{
        cout << "Stack ist leer" << endl;
        return 0;
    }
}


void destroyStack(Stack *s){
    // ! auch content freigeben
    for(int i=s->top; i>=1; i--)
        s->content--;
    s->content++;
    free(s->content);

    free(s);
}

int main(){

    Stack *s;

    s=createStack(3);
    push(s, 'a');
    push(s, 'b');
    push(s, 'c');
    push(s, 'd');

    cout << pop(s) << endl;
    cout << pop(s) << endl;
    cout << pop(s) << endl;
    cout << pop(s) << endl;

    destroyStack(s);
    cin.ignore();
    return 0;
}



top ist auf 0, wenn sich im Stack nichts befindet.
wenn top == depth dann ist der Stack voll.
wenn der Stack leer ist, dann ist content die ursprüngliche Adresse minus 1.
Beim Freigeben wird content vorher auf die ursprüngliche Adresse gebracht.

Das was ao zu pop vorgeschlagen hat, solltest du noch ergänzen.

Zitat von ao:

Außerdem sollte pop das gepoppte Element nicht auf den Bildschirm schreiben, sondern zurückgeben (per Referenzparameter) und über einen bool-schen Returnwert anzeigen, ob der Stack leer war oder nicht.


--
Wenn das Gehirn so einfach wäre, dass wir es verstehen könnten, wären wir so einfach, dass wir es nicht verstehen könnten.
(Emerson Pugh Trost)

Dieser Post wurde am 22.10.2008 um 21:01 Uhr von Lensflare editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] > 2 < [ 3 ]     [ C / C++ (WinAPI, Konsole) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: