Stapel(stack)

[goto anywhere*]

Dann nimmt man wohl am besten gleich C++ und die STL, wenn man's auf Einfachheit absieht:

#include <iostream>
#include <cstdlib>
#include <string>
#include <stack>

typedef struct{
	unsigned int alter;
	unsigned int gehalt;
	std::string name;
}st_el;

int main(void){
	std::stack<st_el>	stack;
	st_el				el={0,0,"Name"};

	for(int cnt=0;cnt<100;++cnt)
		stack.push(el);

	for(int cnt=0;cnt<100;++cnt){
		el=stack.top(); stack.pop();
		std::cout<<el.alter<<", "<<el.gehalt<<", "<<el.name<<std::endl;
	}

	std::cin.get();
}

[Tachyon]

goto anywhere; schrieb:

Dann nimmt man wohl am besten gleich C++ und die STL, wenn man's auf Einfachheit absieht:

a) Soll er selbst einen Stack entwerfen, und nicht einen fertigen benutzen
b) Ist es durch aus ein Unterschied, ob man C oder C++ benutzt, vor allem, wenn in den Anforderungen C als Programmiersprache angegeben wird.

[RapIstMeinHobby]

goto anywhere; schrieb:

Dann nimmt man wohl am besten gleich C++ und die STL, wenn man's auf Einfachheit absieht:

#include <iostream>
#include <cstdlib>
#include <string>
#include <stack>

typedef struct{
	unsigned int alter;
	unsigned int gehalt;
	std::string name;
}st_el;

int main(void){
	std::stack<st_el>	stack;
	st_el				el={0,0,"Name"};

	for(int cnt=0;cnt<100;++cnt)
		stack.push(el);

	for(int cnt=0;cnt<100;++cnt){
		el=stack.top(); stack.pop();
		std::cout<<el.alter<<", "<<el.gehalt<<", "<<el.name<<std::endl;
	}

	std::cin.get();
}

kannst du mit diesem hässlichen kram bitte mal aus dem ansi c forum abhauen? danke.

[Laufentenwickler]

Entwerfe doch zuerst einen Stack mit einer Maximalhöhe, das Grundgerüst etwa so:

#define STACKMAX 100

typedef struct {
    int size;
    int data[STACKMAX];
} Stack;

void createStack(Stack* s) {...};
int pop(Stack* s);
void push(Stack* s, int val);

Hoffe das hilft. Machts doch nicht zu kompliziert. Er weiß noch nicht was Zeiger sind und ihr schlagt verkettete Listen vor. Scherzkekse. Lass die Finger davon und versuch dich an was einfachem.

[windozer]

das macht man aber mit einer liste, das wird ihm der prof in der vorlesung auch so gesagt haben. alles andere ist doch quatsch.

[goto anywhere*]

Laufentenwickler schrieb:

Entwerfe doch zuerst einen Stack mit einer Maximalhöhe, das Grundgerüst etwa so:

#define STACKMAX 100

typedef struct {
    int size;
    int data[STACKMAX];
} Stack;

void createStack(Stack* s) {...};
int pop(Stack* s);
void push(Stack* s, int val);

Hoffe das hilft. Machts doch nicht zu kompliziert. Er weiß noch nicht was Zeiger sind und ihr schlagt verkettete Listen vor. Scherzkekse. Lass die Finger davon und versuch dich an was einfachem.

Du meinst man sollte 'dynamisch' über den Haufen werfen?-Also so etwas in der Art?:

#define STACKLENGHT 10

const int POP=0;
const int PUSH=1;

typedef struct{
	unsigned int alter;
	unsigned int gehalt;
	char name[1024];
}st_el;

int stack(int push_or_pop,st_el *element){
	static st_el stack[STACKLENGHT]={0};
	static int st_ptr=0;

	if(push_or_pop==PUSH){
		if(st_ptr<STACKLENGHT){
			stack[st_ptr++]=*element;
			return 0;
		}
		else{
			return -1;
		}
	}
	else{
		if(st_ptr>0){
			*element=stack[--st_ptr];
			return 0;
		}
		else{
			return -1;
		}
	}
}

[B.B.]

windozer schrieb:

das macht man aber mit einer liste, das wird ihm der prof in der vorlesung auch so gesagt haben. alles andere ist doch quatsch.

Nö.
Vorzugsweise schätzt man die benötigte Größe ab und nimmt einen Speicherblock, der etwas größer ist.
Wird der Block trotdem mal zu klein, wählt man einen nächst größeren.
Oder noch besser, man legt einen zweiten Stack an.

[Laufentenwickler]

@goto anywhere: Nein, so meinte ich das bestimmt nicht. Eher so:

#define STACKMAX 100

typedef struct {
    int size;
    int data[STACKMAX];
} Stack;

void init(Stack* s) {
    s->size = 0;
};
int pop(Stack* s) {
    return s->data[--s->size];
};
void push(Stack* s, int val) {
    s->data[s->size++] = val;
}

...
Stack test;
init(test);
push(test, 1);
push(test, 2);
printf("%d", pop(test));
push(test, 3);
printf("%d", pop(test));
printf("%d", pop(test));

Das kann man dann noch mit Fehlererkennung (overflow, underflow) und dann durch ralloc erweitern, dann eventuell sich noch Gedanken über eine sinvolle Strategie für Stackgroße und Vergrößerung, und man hat schon was sehr brauchbares zusammen.

[aufgabenversteher-freak]

Entwerfen Sie ein Programm (Datenentwurf und Modulentwurf als Struktogramm) zum Hinzufügen von beliebig vielen Elementen in einen Stapel (stack) nach Wunsch.

[Fuzzy+]

aufgabenversteher-freak schrieb:

Entwerfen Sie ein Programm (Datenentwurf und Modulentwurf als Struktogramm) zum Hinzufügen von beliebig vielen Elementen in einen Stapel (stack) nach Wunsch.

Das ist nicht realierbar. Es gibt nicht beliebig viel Speicherplatz.

[iterations-flamer]

Es gibt nicht beliebig viel Speicherplatz.

Und deshalb ist pi auch 3+1/7.

[Tachyon]

iterations-flamer schrieb:

Es gibt nicht beliebig viel Speicherplatz.

Und deshalb ist pi auch 3+1/7.

Ja? Und ich dachte immer, pi = acos(-1.0)...

[ohmanrolf]

ihr seid mal wieder lollig

[Fuzzy+]

iterations-flamer schrieb:

Es gibt nicht beliebig viel Speicherplatz.

Und deshalb ist pi auch 3+1/7.

Was hat denn das jetzt damit zu tun.

[hasso]

hey leute..

Wie ich sehe habt ihr verschieden viele varianten das problem zu lösen ... langsam blick ich nicht mehr durch welche die sinnvollste ist.

Hab mich heut den ganzen tag mit zeiger auseinandergesetzt und morgen werd ich mich mit realloc und malloc und strukturen.... beschäftigen...

Welche ist nun die sinnvollste bzw unkomplitzierteste die auch die Aufgabenstellung erfüllt.?

gruß

[realloc-freak]

hasso schrieb:

Welche ist nun die sinnvollste bzw unkomplitzierteste die auch die Aufgabenstellung erfüllt.?

na die 'realloc'-version natürlich. da kopierste einfach die elemente mit memcpy rein und brauchst keine linked list zu managen. eine beliebte methode sowas zu machen ist, den speicher einfach zu verdoppeln, wenn das element nicht mehr reinpasst. im unterschied zu der verkettetn liste werden heapmanagement-funktionen viel seltener aufgerufen d.h. es ist schneller und der heap fragmentiert nicht so stark. noch besser, wenn du mit einer schicken zweierpotenz beginnst (z.b. 1024 oder sowas) beginnst.

[aufgabenversteher]

realloc-freak schrieb:

hasso schrieb:

Welche ist nun die sinnvollste bzw unkomplitzierteste die auch die Aufgabenstellung erfüllt.?

na die 'realloc'-version natürlich. da kopierste einfach die elemente mit memcpy rein und brauchst keine linked list zu managen. eine beliebte methode sowas zu machen ist, den speicher einfach zu verdoppeln, wenn das element nicht mehr reinpasst. im unterschied zu der verkettetn liste werden heapmanagement-funktionen viel seltener aufgerufen d.h. es ist schneller und der heap fragmentiert nicht so stark. noch besser, wenn du mit einer schicken zweierpotenz beginnst (z.b. 1024 oder sowas) beginnst.

in der aufgabe geht es doch in erster linie erstmal, überhaupt einen stack mit einer gewünschten größe zu erstellen ( eingabe ).
mit realloc hat das erstmal gar nichts zu tun, das wäre als eine denkbare erweiterung anzusehen

[grammatikverbesserer]

in der aufgabe geht es doch in erster linie erstmal darum, überhaupt einen stack mit einer gewünschten größe zu erstellen ( eingabe ).
mit realloc hat das erstmal gar nichts zu tun, das wäre als eine denkbare erweiterung anzusehen

[yottabytes-freak]

grammatikverbesserer schrieb:

in der aufgabe geht es doch in erster linie erstmal darum, überhaupt einen stack mit einer gewünschten größe zu erstellen ( eingabe ).

da steht irgendwas von 'beliebiger' grösse. ohne eine allokator-funktion oder sowas wird man dem wohl kaum gerecht werden (auch wenn man in der praxis natürlich nicht unendlich viel speicher hat).

[sTaCkCrEaToR]

da wird man wohl erstmal malloc nehmen, gelle woll