Stack Implementation

[/code]
#include "stack.h"
#include <iostream>
using namespace std;

Stack* Stack::create_stack(unsigned int size)
{
Stack *s = new Stack;
s->depth = size - 1;
s->content = new char[size];
s->top = 0;
return s;
}

void Stack::push(Stack *, char)
{
top++;
*content = top;

}

char Stack::pop(Stack
{
top--;
*content = top;
return *content;
}

int Stack::isEmpty(Stack
{
if (top == 0);

return 0;

}

void Stack::destroy_stack(Stack
{
delete content;
content = NULL;
}[/code]

Das hab ich soweit zusammengewurschtelt, ich weiß nicht wie ich die isEmpty Methode richtig realisieren soll und auch nicht wie ich depth miteinbeziehen soll. Momentan hab ich eine Endlosschleife.

Bashar

Wieso machst du das jetzt objektorientiert? Hat sich die Aufgabenstellung geändert? Ich dachte die Deklarationen der Struktur und der Funktionen wären vorgegeben.

edit: Die Funktion create_stack sähe ganz gut aus, wenn sie immer noch die alte Signatur hätte. Als Methode ist sie schwachsinnig, ihre Aufgabe würde von einem Konstruktor übernommen werden.

Der Rest ist fast kompletter Unsinn. Ich hoffe stark du bist dir dessen bewusst, ansonsten können wir direkt aufhören und du fängst nochmal ganz von vorne an, C++ zu lernen.

SeppJ

plantplant schrieb:

Das hab ich soweit zusammengewurschtelt, ich weiß nicht wie ich die isEmpty Methode richtig realisieren soll und auch nicht wie ich depth miteinbeziehen soll. Momentan hab ich eine Endlosschleife.

Mal langsam. Du scheinst dir gar nicht klar zu sein, was content, top und depth hier für eine Bedeutung haben. Versuch das mal heraus zu finden und uns zu erklären. Gib nicht einfach nur die Aufgabenstellung wieder. Versuch es jemandem zu erklären, der nicht weiß, wie ein Stack funktioniert. Ich finde, diese Methode funktioniert sehr gut, wenn man selber genauer wissen möchte, wie etwas genau funktioniert. Stell dir auch in Gedanken Gegenfragen, die dein Gegenüber haben könnte und komm ihnen zuvor. Mal eventuell ein paar Bildchen.

Hi,
ich habe das mal aus neugier umgesetzt, funktioniert auch soweit, aber ich frage mich was depth nun denn genau sein soll? Im moment habe ich depth als maxmiale Größe des Stacks verwendet(also eher sowas wie "size"), die vom Wort her sinnvollere Verwendung wäre aber die aktuelle Größe des Stacks, was wiederum nicht so sinnvoll wäre, weil in top der gleiche Informationsgehalt drinsteckt. Wollte also nur kurz nachfragen wie depth gemeint ist.

Bashar

Seh ich genauso, hab ich genauso interpretiert. Was gemeint ist, weiß aber nur der Aufgabensteller. Und der OP natürlich, der saß ja in der Vorlesung, in der das definiert wurde.

hustbaer

Ich denke auch dass depth == allocated die einzig sinnvolle Auslegung ist.

Swordfish

Würd' mir jemand bitte meine Implementierung um die Ohren haun?

stack.h

/*    Aufgabe 0.3 (Projekt Stack) (Vorleistung!Abgabe auf Papier und elektronisch)
 *    Implementieren Sie einen Datentyp STACK, der nach dem LIFO - Prinzip arbeitet und einzelne Buchstaben aufnehmen kann. Verwenden Sie dazu folgende Datenstruktur.
 */

#ifndef STACK_H_INCLUDED
#define STACK_H_INCLUDED STACK_H_INCLUDED

struct Stack {
	unsigned int  depth;     // Tiefe des Stacks
	char *        content;   // Inhalt des Stacks
	unsigned int  top;       // Index des obersten freien Elements
};

/*    und implementieren Sie die folgenden Funktionen:
 */

Stack * create_stack  ( unsigned int size );
void    push          ( Stack * s, char value );
char    pop           ( Stack * s );
int     isEmpty       ( Stack * s );
void    destroy_stack ( Stack * s );

#endif /* STACK_H_INCLUDED */

stack.cpp

/*    Aufgabe 0.3 (Projekt Stack) (Vorleistung!Abgabe auf Papier und elektronisch)
 *    Implementieren Sie einen Datentyp STACK, der nach dem LIFO - Prinzip arbeitet und einzelne Buchstaben aufnehmen kann. Implementieren Sie die folgenden Funktionen:
 */

#include "stack.h"

#include <cstdlib>

Stack * create_stack( unsigned int size )
{
	if( !size )
		size = 0x0f;

	Stack * s  = static_cast< Stack * >( std::malloc( sizeof Stack ) );

	if( !s )
		return 0;

	s->content = static_cast< char *  >( std::malloc( size ) );

	if( !s->content ) {
		free( s );
		return 0;
	}

	s->depth   = size;
	s->top     = 0;

	return s;
}

void push( Stack * s, char value )
{
	if( s->top == s->depth ) {

		char * new_content = static_cast< char * >( std::realloc( s->content, s->depth * 2 ) );
		if( !new_content )
			return;

		s->content = new_content;
		s->depth  *= 2;
	}

	s->content[ s->top++ ] = value;
}

char pop( Stack * s )
{
	if( !isEmpty( s ) ) {

		s->top--;
		return s->content[ s->top ];

	}

	return 0;
}

int  isEmpty( Stack * s )
{
	return !s->top ? true : false;
}

void destroy_stack ( Stack * s )
{
	free( s->content );
	free( s );
}

main.cpp

/*    Aufgabe 0.3 (Projekt Stack) (Vorleistung!Abgabe auf Papier und elektronisch)
 *    Implementieren Sie einen Datentyp STACK, der nach dem LIFO - Prinzip arbeitet und einzelne Buchstaben aufnehmen kann.
 *    Testen Sie Ihre Implementierung mit Hilfe des folgenden Hauptprogramms:
 */

#include <iostream>
using namespace std;

#include "stack.h"

int main()
{
	// Test der Datenstruktur STACK
	Stack * s;
	s = create_stack( 3 );
	push( s, 'a' );
	push( s, 'b' );
	push( s, 'c' );
	push( s, 'd' );
	while ( !isEmpty( s ) )
		cout << pop( s ) << '\n'; /* << endl;   wtf? */
	pop( s );
	destroy_stack( s );
	/* cin.ignore();   wtf? */
	/* return 0; */ return EXIT_SUCCESS;
}

TyRoXx

Swordfish schrieb:

Würd' mir jemand bitte meine Implementierung um die Ohren haun?

Sehr gerne.

Der Typ von depth und top ist schon in der Aufgabenstellung falsch, also gehe ich darauf nicht weiter ein.

#define STACK_H_INCLUDED STACK_H_INCLUDED

Was soll das bewirken?

Stack * create_stack( unsigned int size )
{
	if( !size )
		size = 0x0f;

Warum ist 0 hier ein Spezialfall? Woher kommt die 15? Warum hexadezimal?

Stack * s  = static_cast< Stack * >( std::malloc( sizeof Stack ) );

sizeof(*s) ist das Mindeste, das man hier zur Sicherheit tun kann.

char * new_content = static_cast< char * >( std::realloc( s->content, s->depth * 2 ) );

Die Multiplikation kann überlaufen.

char pop( Stack * s )
{
	if( !isEmpty( s ) ) {

		s->top--;
		return s->content[ s->top ];

	}

	return 0;
}

Warum kein assert ? Den unsinnigen "Test" in der Aufgabenstellung hätte man doch korrigieren können.

return !s->top ? true : false;

Really?

Swordfish

TyRoXx schrieb:

Swordfish schrieb:

Würd' mir jemand bitte meine Implementierung um die Ohren haun?

Sehr gerne.

Danke!

TyRoXx schrieb:

Der Typ von depth und top ist schon in der Aufgabenstellung falsch, also gehe ich darauf nicht weiter ein.

Jaaa, das ist mir wohl bewusst. Ich hab mich trotzdem an die an mehreren Stellen kaputte Aufgabenstellung gehalten.

TyRoXx schrieb:

#define STACK_H_INCLUDED STACK_H_INCLUDED
Was soll das bewirken?

Sollte ein Holzkopf darauf kommen, STACK_H_INCLUDED als Bezeichner zu verwenden, so wird es wenigstens gegen sich selbst ersetzt. Eine Angewohnheit.

TyRoXx schrieb:

Stack * create_stack( unsigned int size )
{
	if( !size )
		size = 0x0f;
Warum ist 0 hier ein Spezialfall? Woher kommt die 15? Warum hexadezimal?

Gute Frage. Weil ich nicht mit einem Stack ohne Kapazität starten wollt, falls der Benutzer 0 übergibt. Die 0x0f kommt daher, daß ich nicht weiß, welcher andere Initialwert effizienter wäre.

TyRoXx schrieb:

Stack * s  = static_cast< Stack * >( std::malloc( sizeof Stack ) );
sizeof(*s) ist das Mindeste, das man hier zur Sicherheit tun kann.

Check ich ned. sizeof( *s ) ist doch gerade sizeof( Stack ) ?

TyRoXx schrieb:

char * new_content = static_cast< char * >( std::realloc( s->content, s->depth * 2 ) );

Die Multiplikation kann überlaufen.

Stimmt. Das sollt man prüfen. Hab' ich ausgelassen, weil ich den Testfall kenne.

TyRoXx schrieb:

char pop( Stack * s )
{
	if( !isEmpty( s ) ) {
		
		s->top--;
		return s->content[ s->top ];

	}
	
	return 0;
}
Warum kein assert ? Den unsinnigen "Test" in der Aufgabenstellung hätte man doch korrigieren können.

Wie gesagt, ich habe mich an die verbuggte Aufgabenstellung gehalten.

TyRoXx schrieb:

return !s->top ? true : false;

Really?

Why not?

Swordfish

TyRoXx schrieb:

return !s->top ? true : false;

Really?

... oder meinst man sollt' es umdrehen:

return s->top ? false : true;

?

Nathan

return s->top == 0;

?

Columbo

Falls das ernst gemeint ist: Nein, es soll eher

return s->top == 0;

sein.

Sollte ein Holzkopf darauf kommen, STACK_H_INCLUDED als Bezeichner zu verwenden, so wird es wenigstens gegen sich selbst ersetzt.

Nein, das ist Quatsch. Mit deiner Variante wird er gar keine Fehlermeldung bekommen obwohl sein Bezeichner ein Objektmakro anspricht.

Swordfish

Arcoth schrieb:

Falls das ernst gemeint ist: Nein, es soll eher
return s->top == 0;
sein.

Yay, warum komm ich auf sowas ned?

Arcoth schrieb:

Swordfish schrieb:

Sollte ein Holzkopf darauf kommen, STACK_H_INCLUDED als Bezeichner zu verwenden, so wird es wenigstens gegen sich selbst ersetzt.

Nein, das ist Quatsch. Mit deiner Variante wird er gar keine Fehlermeldung bekommen obwohl sein Bezeichner ein Objektmakro anspricht.

Jaaa. Ich sagt' ja: Angewohnheit.